hw.h 25.8 KB
Newer Older
P
pbrook 已提交
1 2 3 4 5
/* Declarations for use by hardware emulation.  */
#ifndef QEMU_HW_H
#define QEMU_HW_H

#include "qemu-common.h"
P
Paul Brook 已提交
6 7 8 9 10 11 12

#if defined(TARGET_PHYS_ADDR_BITS) && !defined(NEED_CPU_H)
#include "targphys.h"
#include "poison.h"
#include "cpu-common.h"
#endif

13
#include <stdbool.h>
14
#include "ioport.h"
P
pbrook 已提交
15 16 17 18
#include "irq.h"

/* VM Load/Save */

A
aliguori 已提交
19 20 21 22
/* This function writes a chunk of data to a file at the given position.
 * The pos argument can be ignored if the file is only being used for
 * streaming.  The handler should try to write all of the data it can.
 */
A
aliguori 已提交
23 24
typedef int (QEMUFilePutBufferFunc)(void *opaque, const uint8_t *buf,
                                    int64_t pos, int size);
A
aliguori 已提交
25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40

/* Read a chunk of data from a file at the given position.  The pos argument
 * can be ignored if the file is only be used for streaming.  The number of
 * bytes actually read should be returned.
 */
typedef int (QEMUFileGetBufferFunc)(void *opaque, uint8_t *buf,
                                    int64_t pos, int size);

/* Close a file and return an error code */
typedef int (QEMUFileCloseFunc)(void *opaque);

/* Called to determine if the file has exceeded it's bandwidth allocation.  The
 * bandwidth capping is a soft limit, not a hard limit.
 */
typedef int (QEMUFileRateLimit)(void *opaque);

41 42 43 44 45 46
/* Called to change the current bandwidth allocation. This function must return
 * the new actual bandwidth. It should be new_rate if everything goes ok, and
 * the old rate otherwise
 */
typedef size_t (QEMUFileSetRateLimit)(void *opaque, size_t new_rate);

A
aliguori 已提交
47 48 49
QEMUFile *qemu_fopen_ops(void *opaque, QEMUFilePutBufferFunc *put_buffer,
                         QEMUFileGetBufferFunc *get_buffer,
                         QEMUFileCloseFunc *close,
50 51
                         QEMUFileRateLimit *rate_limit,
                         QEMUFileSetRateLimit *set_rate_limit);
P
pbrook 已提交
52
QEMUFile *qemu_fopen(const char *filename, const char *mode);
P
Paolo Bonzini 已提交
53
QEMUFile *qemu_fdopen(int fd, const char *mode);
54
QEMUFile *qemu_fopen_socket(int fd);
55 56
QEMUFile *qemu_popen(FILE *popen_file, const char *mode);
QEMUFile *qemu_popen_cmd(const char *command, const char *mode);
P
Paolo Bonzini 已提交
57
int qemu_stdio_fd(QEMUFile *f);
P
pbrook 已提交
58
void qemu_fflush(QEMUFile *f);
A
aliguori 已提交
59
int qemu_fclose(QEMUFile *f);
60 61
void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size);
void qemu_put_byte(QEMUFile *f, int v);
B
blueswir1 已提交
62 63 64 65 66 67 68 69

static inline void qemu_put_ubyte(QEMUFile *f, unsigned int v)
{
    qemu_put_byte(f, (int)v);
}

#define qemu_put_sbyte qemu_put_byte

70 71
void qemu_put_be16(QEMUFile *f, unsigned int v);
void qemu_put_be32(QEMUFile *f, unsigned int v);
P
pbrook 已提交
72
void qemu_put_be64(QEMUFile *f, uint64_t v);
73 74
int qemu_get_buffer(QEMUFile *f, uint8_t *buf, int size);
int qemu_get_byte(QEMUFile *f);
B
blueswir1 已提交
75 76 77 78 79 80 81 82

static inline unsigned int qemu_get_ubyte(QEMUFile *f)
{
    return (unsigned int)qemu_get_byte(f);
}

#define qemu_get_sbyte qemu_get_byte

83 84
unsigned int qemu_get_be16(QEMUFile *f);
unsigned int qemu_get_be32(QEMUFile *f);
P
pbrook 已提交
85
uint64_t qemu_get_be64(QEMUFile *f);
A
aliguori 已提交
86
int qemu_file_rate_limit(QEMUFile *f);
87
size_t qemu_file_set_rate_limit(QEMUFile *f, size_t new_rate);
A
aliguori 已提交
88
int qemu_file_has_error(QEMUFile *f);
89
void qemu_file_set_error(QEMUFile *f);
A
aliguori 已提交
90 91 92 93 94

/* Try to send any outstanding data.  This function is useful when output is
 * halted due to rate limiting or EAGAIN errors occur as it can be used to
 * resume output. */
void qemu_file_put_notify(QEMUFile *f);
P
pbrook 已提交
95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135

static inline void qemu_put_be64s(QEMUFile *f, const uint64_t *pv)
{
    qemu_put_be64(f, *pv);
}

static inline void qemu_put_be32s(QEMUFile *f, const uint32_t *pv)
{
    qemu_put_be32(f, *pv);
}

static inline void qemu_put_be16s(QEMUFile *f, const uint16_t *pv)
{
    qemu_put_be16(f, *pv);
}

static inline void qemu_put_8s(QEMUFile *f, const uint8_t *pv)
{
    qemu_put_byte(f, *pv);
}

static inline void qemu_get_be64s(QEMUFile *f, uint64_t *pv)
{
    *pv = qemu_get_be64(f);
}

static inline void qemu_get_be32s(QEMUFile *f, uint32_t *pv)
{
    *pv = qemu_get_be32(f);
}

static inline void qemu_get_be16s(QEMUFile *f, uint16_t *pv)
{
    *pv = qemu_get_be16(f);
}

static inline void qemu_get_8s(QEMUFile *f, uint8_t *pv)
{
    *pv = qemu_get_byte(f);
}

B
blueswir1 已提交
136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216
// Signed versions for type safety
static inline void qemu_put_sbuffer(QEMUFile *f, const int8_t *buf, int size)
{
    qemu_put_buffer(f, (const uint8_t *)buf, size);
}

static inline void qemu_put_sbe16(QEMUFile *f, int v)
{
    qemu_put_be16(f, (unsigned int)v);
}

static inline void qemu_put_sbe32(QEMUFile *f, int v)
{
    qemu_put_be32(f, (unsigned int)v);
}

static inline void qemu_put_sbe64(QEMUFile *f, int64_t v)
{
    qemu_put_be64(f, (uint64_t)v);
}

static inline size_t qemu_get_sbuffer(QEMUFile *f, int8_t *buf, int size)
{
    return qemu_get_buffer(f, (uint8_t *)buf, size);
}

static inline int qemu_get_sbe16(QEMUFile *f)
{
    return (int)qemu_get_be16(f);
}

static inline int qemu_get_sbe32(QEMUFile *f)
{
    return (int)qemu_get_be32(f);
}

static inline int64_t qemu_get_sbe64(QEMUFile *f)
{
    return (int64_t)qemu_get_be64(f);
}

static inline void qemu_put_s8s(QEMUFile *f, const int8_t *pv)
{
    qemu_put_8s(f, (const uint8_t *)pv);
}

static inline void qemu_put_sbe16s(QEMUFile *f, const int16_t *pv)
{
    qemu_put_be16s(f, (const uint16_t *)pv);
}

static inline void qemu_put_sbe32s(QEMUFile *f, const int32_t *pv)
{
    qemu_put_be32s(f, (const uint32_t *)pv);
}

static inline void qemu_put_sbe64s(QEMUFile *f, const int64_t *pv)
{
    qemu_put_be64s(f, (const uint64_t *)pv);
}

static inline void qemu_get_s8s(QEMUFile *f, int8_t *pv)
{
    qemu_get_8s(f, (uint8_t *)pv);
}

static inline void qemu_get_sbe16s(QEMUFile *f, int16_t *pv)
{
    qemu_get_be16s(f, (uint16_t *)pv);
}

static inline void qemu_get_sbe32s(QEMUFile *f, int32_t *pv)
{
    qemu_get_be32s(f, (uint32_t *)pv);
}

static inline void qemu_get_sbe64s(QEMUFile *f, int64_t *pv)
{
    qemu_get_be64s(f, (uint64_t *)pv);
}

P
pbrook 已提交
217 218 219 220 221 222
#ifdef NEED_CPU_H
#if TARGET_LONG_BITS == 64
#define qemu_put_betl qemu_put_be64
#define qemu_get_betl qemu_get_be64
#define qemu_put_betls qemu_put_be64s
#define qemu_get_betls qemu_get_be64s
B
blueswir1 已提交
223 224 225 226
#define qemu_put_sbetl qemu_put_sbe64
#define qemu_get_sbetl qemu_get_sbe64
#define qemu_put_sbetls qemu_put_sbe64s
#define qemu_get_sbetls qemu_get_sbe64s
P
pbrook 已提交
227 228 229 230 231
#else
#define qemu_put_betl qemu_put_be32
#define qemu_get_betl qemu_get_be32
#define qemu_put_betls qemu_put_be32s
#define qemu_get_betls qemu_get_be32s
B
blueswir1 已提交
232 233 234 235
#define qemu_put_sbetl qemu_put_sbe32
#define qemu_get_sbetl qemu_get_sbe32
#define qemu_put_sbetls qemu_put_sbe32s
#define qemu_get_sbetls qemu_get_sbe32s
P
pbrook 已提交
236 237 238 239 240 241 242
#endif
#endif

int64_t qemu_ftell(QEMUFile *f);
int64_t qemu_fseek(QEMUFile *f, int64_t pos, int whence);

typedef void SaveStateHandler(QEMUFile *f, void *opaque);
A
aliguori 已提交
243
typedef int SaveLiveStateHandler(QEMUFile *f, int stage, void *opaque);
P
pbrook 已提交
244 245 246 247 248 249 250 251 252
typedef int LoadStateHandler(QEMUFile *f, void *opaque, int version_id);

int register_savevm(const char *idstr,
                    int instance_id,
                    int version_id,
                    SaveStateHandler *save_state,
                    LoadStateHandler *load_state,
                    void *opaque);

A
aliguori 已提交
253 254 255 256 257 258 259 260
int register_savevm_live(const char *idstr,
                         int instance_id,
                         int version_id,
                         SaveLiveStateHandler *save_live_state,
                         SaveStateHandler *save_state,
                         LoadStateHandler *load_state,
                         void *opaque);

261 262
void unregister_savevm(const char *idstr, void *opaque);

P
pbrook 已提交
263 264
typedef void QEMUResetHandler(void *opaque);

265
void qemu_register_reset(QEMUResetHandler *func, void *opaque);
J
Jan Kiszka 已提交
266
void qemu_unregister_reset(QEMUResetHandler *func, void *opaque);
P
pbrook 已提交
267

J
Jan Kiszka 已提交
268
/* handler to set the boot_device order for a specific type of QEMUMachine */
269
/* return 0 if success */
J
Jan Kiszka 已提交
270
typedef int QEMUBootSetHandler(void *opaque, const char *boot_devices);
271
void qemu_register_boot_set(QEMUBootSetHandler *func, void *opaque);
J
Jan Kiszka 已提交
272
int qemu_boot_set(const char *boot_devices);
273

274 275 276 277 278 279
typedef struct VMStateInfo VMStateInfo;
typedef struct VMStateDescription VMStateDescription;

struct VMStateInfo {
    const char *name;
    int (*get)(QEMUFile *f, void *pv, size_t size);
280
    void (*put)(QEMUFile *f, void *pv, size_t size);
281 282 283
};

enum VMStateFlags {
J
Juan Quintela 已提交
284 285 286 287
    VMS_SINGLE           = 0x001,
    VMS_POINTER          = 0x002,
    VMS_ARRAY            = 0x004,
    VMS_STRUCT           = 0x008,
288
    VMS_VARRAY_INT32     = 0x010,  /* Array with size in int32_t field*/
J
Juan Quintela 已提交
289
    VMS_BUFFER           = 0x020,  /* static sized buffer */
290
    VMS_ARRAY_OF_POINTER = 0x040,
291
    VMS_VARRAY_UINT16    = 0x080,  /* Array with size in uint16_t field */
292 293 294 295 296 297
};

typedef struct {
    const char *name;
    size_t offset;
    size_t size;
J
Juan Quintela 已提交
298
    int num;
299
    size_t num_offset;
300 301
    const VMStateInfo *info;
    enum VMStateFlags flags;
J
Juan Quintela 已提交
302
    const VMStateDescription *vmsd;
303
    int version_id;
304
    bool (*field_exists)(void *opaque, int version_id);
305 306 307 308 309 310 311 312
} VMStateField;

struct VMStateDescription {
    const char *name;
    int version_id;
    int minimum_version_id;
    int minimum_version_id_old;
    LoadStateHandler *load_state_old;
J
Juan Quintela 已提交
313
    int (*pre_load)(void *opaque);
314
    int (*post_load)(void *opaque, int version_id);
315 316
    void (*pre_save)(void *opaque);
    void (*post_save)(void *opaque);
317 318 319 320 321 322 323 324
    VMStateField *fields;
};

extern const VMStateInfo vmstate_info_int8;
extern const VMStateInfo vmstate_info_int16;
extern const VMStateInfo vmstate_info_int32;
extern const VMStateInfo vmstate_info_int64;

325
extern const VMStateInfo vmstate_info_uint8_equal;
326
extern const VMStateInfo vmstate_info_uint16_equal;
327
extern const VMStateInfo vmstate_info_int32_equal;
328
extern const VMStateInfo vmstate_info_int32_le;
329

330 331 332 333 334
extern const VMStateInfo vmstate_info_uint8;
extern const VMStateInfo vmstate_info_uint16;
extern const VMStateInfo vmstate_info_uint32;
extern const VMStateInfo vmstate_info_uint64;

J
Juan Quintela 已提交
335
extern const VMStateInfo vmstate_info_timer;
B
Blue Swirl 已提交
336
extern const VMStateInfo vmstate_info_ptimer;
337
extern const VMStateInfo vmstate_info_buffer;
J
Juan Quintela 已提交
338
extern const VMStateInfo vmstate_info_unused_buffer;
J
Juan Quintela 已提交
339

J
Juan Quintela 已提交
340
#define type_check_array(t1,t2,n) ((t1(*)[n])0 - (t2*)0)
341
#define type_check_pointer(t1,t2) ((t1**)0 - (t2*)0)
J
Juan Quintela 已提交
342

343 344 345 346
#define vmstate_offset_value(_state, _field, _type)                  \
    (offsetof(_state, _field) +                                      \
     type_check(_type, typeof_field(_state, _field)))

347 348 349 350
#define vmstate_offset_pointer(_state, _field, _type)                \
    (offsetof(_state, _field) +                                      \
     type_check_pointer(_type, typeof_field(_state, _field)))

351 352 353 354
#define vmstate_offset_array(_state, _field, _type, _num)            \
    (offsetof(_state, _field) +                                      \
     type_check_array(_type, typeof_field(_state, _field), _num))

355 356 357 358
#define vmstate_offset_buffer(_state, _field)                        \
    vmstate_offset_array(_state, _field, uint8_t,                    \
                         sizeof(typeof_field(_state, _field)))

359
#define VMSTATE_SINGLE_TEST(_field, _state, _test, _version, _info, _type) { \
360
    .name         = (stringify(_field)),                             \
361
    .version_id   = (_version),                                      \
362 363 364 365
    .field_exists = (_test),                                         \
    .size         = sizeof(_type),                                   \
    .info         = &(_info),                                        \
    .flags        = VMS_SINGLE,                                      \
366
    .offset       = vmstate_offset_value(_state, _field, _type),     \
367 368
}

J
Juan Quintela 已提交
369 370 371 372 373 374
#define VMSTATE_POINTER(_field, _state, _version, _info, _type) {    \
    .name       = (stringify(_field)),                               \
    .version_id = (_version),                                        \
    .info       = &(_info),                                          \
    .size       = sizeof(_type),                                     \
    .flags      = VMS_SINGLE|VMS_POINTER,                            \
375
    .offset     = vmstate_offset_value(_state, _field, _type),       \
J
Juan Quintela 已提交
376 377
}

J
Juan Quintela 已提交
378 379 380 381 382 383 384
#define VMSTATE_ARRAY(_field, _state, _num, _version, _info, _type) {\
    .name       = (stringify(_field)),                               \
    .version_id = (_version),                                        \
    .num        = (_num),                                            \
    .info       = &(_info),                                          \
    .size       = sizeof(_type),                                     \
    .flags      = VMS_ARRAY,                                         \
385
    .offset     = vmstate_offset_array(_state, _field, _type, _num), \
J
Juan Quintela 已提交
386 387
}

388 389 390 391 392 393 394
#define VMSTATE_ARRAY_TEST(_field, _state, _num, _test, _info, _type) {\
    .name         = (stringify(_field)),                              \
    .field_exists = (_test),                                          \
    .num          = (_num),                                           \
    .info         = &(_info),                                         \
    .size         = sizeof(_type),                                    \
    .flags        = VMS_ARRAY,                                        \
395
    .offset       = vmstate_offset_array(_state, _field, _type, _num),\
396 397
}

398
#define VMSTATE_VARRAY_INT32(_field, _state, _field_num, _version, _info, _type) {\
399 400
    .name       = (stringify(_field)),                               \
    .version_id = (_version),                                        \
401
    .num_offset = vmstate_offset_value(_state, _field_num, int32_t), \
402 403
    .info       = &(_info),                                          \
    .size       = sizeof(_type),                                     \
404
    .flags      = VMS_VARRAY_INT32|VMS_POINTER,                      \
405
    .offset     = vmstate_offset_pointer(_state, _field, _type),     \
406 407
}

408 409 410 411 412 413 414 415 416 417
#define VMSTATE_VARRAY_UINT16_UNSAFE(_field, _state, _field_num, _version, _info, _type) {\
    .name       = (stringify(_field)),                               \
    .version_id = (_version),                                        \
    .num_offset = vmstate_offset_value(_state, _field_num, uint16_t),\
    .info       = &(_info),                                          \
    .size       = sizeof(_type),                                     \
    .flags      = VMS_VARRAY_UINT16,                                 \
    .offset     = offsetof(_state, _field),                          \
}

J
Juan Quintela 已提交
418 419 420 421 422 423
#define VMSTATE_STRUCT(_field, _state, _version, _vmsd, _type) {     \
    .name       = (stringify(_field)),                               \
    .version_id = (_version),                                        \
    .vmsd       = &(_vmsd),                                          \
    .size       = sizeof(_type),                                     \
    .flags      = VMS_STRUCT,                                        \
424
    .offset     = vmstate_offset_value(_state, _field, _type),       \
J
Juan Quintela 已提交
425 426
}

427 428 429 430 431
#define VMSTATE_STRUCT_POINTER(_field, _state, _vmsd, _type) {       \
    .name       = (stringify(_field)),                               \
    .vmsd       = &(_vmsd),                                          \
    .size       = sizeof(_type),                                     \
    .flags      = VMS_STRUCT|VMS_POINTER,                            \
432
    .offset     = vmstate_offset_value(_state, _field, _type),       \
433 434
}

435 436 437 438 439 440 441
#define VMSTATE_ARRAY_OF_POINTER(_field, _state, _num, _version, _info, _type) {\
    .name       = (stringify(_field)),                               \
    .version_id = (_version),                                        \
    .num        = (_num),                                            \
    .info       = &(_info),                                          \
    .size       = sizeof(_type),                                     \
    .flags      = VMS_ARRAY|VMS_ARRAY_OF_POINTER,                    \
442
    .offset     = vmstate_offset_array(_state, _field, _type, _num), \
443 444
}

445 446 447 448 449 450 451
#define VMSTATE_STRUCT_ARRAY(_field, _state, _num, _version, _vmsd, _type) { \
    .name       = (stringify(_field)),                               \
    .num        = (_num),                                            \
    .version_id = (_version),                                        \
    .vmsd       = &(_vmsd),                                          \
    .size       = sizeof(_type),                                     \
    .flags      = VMS_STRUCT|VMS_ARRAY,                              \
452
    .offset     = vmstate_offset_array(_state, _field, _type, _num), \
453 454
}

455 456
#define VMSTATE_STRUCT_ARRAY_SIZE_UINT8(_field, _state, _field__num, _version, _vmsd, _type) { \
    .name       = (stringify(_field)),                               \
457
    .num_offset = vmstate_offset_value(_state, _field_num, uint8_t), \
458 459 460 461
    .version_id = (_version),                                        \
    .vmsd       = &(_vmsd),                                          \
    .size       = sizeof(_type),                                     \
    .flags      = VMS_STRUCT|VMS_ARRAY,                              \
462
    .offset     = vmstate_offset_array(_state, _field, _type, _num), \
463 464
}

465
#define VMSTATE_STATIC_BUFFER(_field, _state, _version, _test, _start, _size) { \
J
Juan Quintela 已提交
466
    .name         = (stringify(_field)),                             \
467
    .version_id   = (_version),                                      \
J
Juan Quintela 已提交
468
    .field_exists = (_test),                                         \
469
    .size         = (_size - _start),                                \
J
Juan Quintela 已提交
470 471
    .info         = &vmstate_info_buffer,                            \
    .flags        = VMS_BUFFER,                                      \
472
    .offset       = vmstate_offset_buffer(_state, _field) + _start,  \
J
Juan Quintela 已提交
473 474
}

J
Juan Quintela 已提交
475 476 477 478 479 480 481 482
#define VMSTATE_UNUSED_BUFFER(_test, _version, _size) {              \
    .name         = "unused",                                        \
    .field_exists = (_test),                                         \
    .version_id   = (_version),                                      \
    .size         = (_size),                                         \
    .info         = &vmstate_info_unused_buffer,                     \
    .flags        = VMS_BUFFER,                                      \
}
J
Juan Quintela 已提交
483 484 485 486 487 488 489
extern const VMStateDescription vmstate_pci_device;

#define VMSTATE_PCI_DEVICE(_field, _state) {                         \
    .name       = (stringify(_field)),                               \
    .size       = sizeof(PCIDevice),                                 \
    .vmsd       = &vmstate_pci_device,                               \
    .flags      = VMS_STRUCT,                                        \
490
    .offset     = vmstate_offset_value(_state, _field, PCIDevice),   \
J
Juan Quintela 已提交
491 492
}

J
Juan Quintela 已提交
493 494 495 496 497 498 499
extern const VMStateDescription vmstate_i2c_slave;

#define VMSTATE_I2C_SLAVE(_field, _state) {                          \
    .name       = (stringify(_field)),                               \
    .size       = sizeof(i2c_slave),                                 \
    .vmsd       = &vmstate_i2c_slave,                                \
    .flags      = VMS_STRUCT,                                        \
500
    .offset     = vmstate_offset_value(_state, _field, i2c_slave),   \
J
Juan Quintela 已提交
501 502
}

503
/* _f : field name
504
   _f_n : num of elements field_name
J
Juan Quintela 已提交
505
   _n : num of elements
506 507 508 509
   _s : struct state name
   _v : version
*/

510 511 512
#define VMSTATE_SINGLE(_field, _state, _version, _info, _type)        \
    VMSTATE_SINGLE_TEST(_field, _state, NULL, _version, _info, _type)

513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548
#define VMSTATE_INT8_V(_f, _s, _v)                                    \
    VMSTATE_SINGLE(_f, _s, _v, vmstate_info_int8, int8_t)
#define VMSTATE_INT16_V(_f, _s, _v)                                   \
    VMSTATE_SINGLE(_f, _s, _v, vmstate_info_int16, int16_t)
#define VMSTATE_INT32_V(_f, _s, _v)                                   \
    VMSTATE_SINGLE(_f, _s, _v, vmstate_info_int32, int32_t)
#define VMSTATE_INT64_V(_f, _s, _v)                                   \
    VMSTATE_SINGLE(_f, _s, _v, vmstate_info_int64, int64_t)

#define VMSTATE_UINT8_V(_f, _s, _v)                                   \
    VMSTATE_SINGLE(_f, _s, _v, vmstate_info_uint8, uint8_t)
#define VMSTATE_UINT16_V(_f, _s, _v)                                  \
    VMSTATE_SINGLE(_f, _s, _v, vmstate_info_uint16, uint16_t)
#define VMSTATE_UINT32_V(_f, _s, _v)                                  \
    VMSTATE_SINGLE(_f, _s, _v, vmstate_info_uint32, uint32_t)
#define VMSTATE_UINT64_V(_f, _s, _v)                                  \
    VMSTATE_SINGLE(_f, _s, _v, vmstate_info_uint64, uint64_t)

#define VMSTATE_INT8(_f, _s)                                          \
    VMSTATE_INT8_V(_f, _s, 0)
#define VMSTATE_INT16(_f, _s)                                         \
    VMSTATE_INT16_V(_f, _s, 0)
#define VMSTATE_INT32(_f, _s)                                         \
    VMSTATE_INT32_V(_f, _s, 0)
#define VMSTATE_INT64(_f, _s)                                         \
    VMSTATE_INT64_V(_f, _s, 0)

#define VMSTATE_UINT8(_f, _s)                                         \
    VMSTATE_UINT8_V(_f, _s, 0)
#define VMSTATE_UINT16(_f, _s)                                        \
    VMSTATE_UINT16_V(_f, _s, 0)
#define VMSTATE_UINT32(_f, _s)                                        \
    VMSTATE_UINT32_V(_f, _s, 0)
#define VMSTATE_UINT64(_f, _s)                                        \
    VMSTATE_UINT64_V(_f, _s, 0)

549 550 551
#define VMSTATE_UINT8_EQUAL(_f, _s)                                   \
    VMSTATE_SINGLE(_f, _s, 0, vmstate_info_uint8_equal, uint8_t)

552 553 554 555 556 557
#define VMSTATE_UINT16_EQUAL(_f, _s)                                  \
    VMSTATE_SINGLE(_f, _s, 0, vmstate_info_uint16_equal, uint16_t)

#define VMSTATE_UINT16_EQUAL_V(_f, _s, _v)                            \
    VMSTATE_SINGLE(_f, _s, _v, vmstate_info_uint16_equal, uint16_t)

558 559 560
#define VMSTATE_INT32_EQUAL(_f, _s)                                   \
    VMSTATE_SINGLE(_f, _s, 0, vmstate_info_int32_equal, int32_t)

561 562 563
#define VMSTATE_INT32_LE(_f, _s)                                   \
    VMSTATE_SINGLE(_f, _s, 0, vmstate_info_int32_le, int32_t)

564
#define VMSTATE_UINT32_TEST(_f, _s, _t)                                  \
565
    VMSTATE_SINGLE_TEST(_f, _s, _t, 0, vmstate_info_uint32, uint32_t)
566

J
Juan Quintela 已提交
567 568 569 570 571 572
#define VMSTATE_TIMER_V(_f, _s, _v)                                   \
    VMSTATE_POINTER(_f, _s, _v, vmstate_info_timer, QEMUTimer *)

#define VMSTATE_TIMER(_f, _s)                                         \
    VMSTATE_TIMER_V(_f, _s, 0)

573 574 575
#define VMSTATE_TIMER_ARRAY(_f, _s, _n)                              \
    VMSTATE_ARRAY_OF_POINTER(_f, _s, _n, 0, vmstate_info_timer, QEMUTimer *)

B
Blue Swirl 已提交
576 577 578 579 580 581
#define VMSTATE_PTIMER_V(_f, _s, _v)                                  \
    VMSTATE_POINTER(_f, _s, _v, vmstate_info_ptimer, ptimer_state *)

#define VMSTATE_PTIMER(_f, _s)                                        \
    VMSTATE_PTIMER_V(_f, _s, 0)

582 583 584 585 586 587
#define VMSTATE_UINT16_ARRAY_V(_f, _s, _n, _v)                         \
    VMSTATE_ARRAY(_f, _s, _n, _v, vmstate_info_uint16, uint16_t)

#define VMSTATE_UINT16_ARRAY(_f, _s, _n)                               \
    VMSTATE_UINT16_ARRAY_V(_f, _s, _n, 0)

J
Juan Quintela 已提交
588 589 590 591 592 593
#define VMSTATE_UINT8_ARRAY_V(_f, _s, _n, _v)                         \
    VMSTATE_ARRAY(_f, _s, _n, _v, vmstate_info_uint8, uint8_t)

#define VMSTATE_UINT8_ARRAY(_f, _s, _n)                               \
    VMSTATE_UINT8_ARRAY_V(_f, _s, _n, 0)

J
Juan Quintela 已提交
594 595 596 597 598 599
#define VMSTATE_UINT32_ARRAY_V(_f, _s, _n, _v)                        \
    VMSTATE_ARRAY(_f, _s, _n, _v, vmstate_info_uint32, uint32_t)

#define VMSTATE_UINT32_ARRAY(_f, _s, _n)                              \
    VMSTATE_UINT32_ARRAY_V(_f, _s, _n, 0)

600 601 602 603 604 605
#define VMSTATE_UINT64_ARRAY_V(_f, _s, _n, _v)                        \
    VMSTATE_ARRAY(_f, _s, _n, _v, vmstate_info_uint64, uint64_t)

#define VMSTATE_UINT64_ARRAY(_f, _s, _n)                              \
    VMSTATE_UINT64_ARRAY_V(_f, _s, _n, 0)

606 607 608 609 610 611
#define VMSTATE_INT16_ARRAY_V(_f, _s, _n, _v)                         \
    VMSTATE_ARRAY(_f, _s, _n, _v, vmstate_info_int16, int16_t)

#define VMSTATE_INT16_ARRAY(_f, _s, _n)                               \
    VMSTATE_INT16_ARRAY_V(_f, _s, _n, 0)

J
Juan Quintela 已提交
612 613 614 615 616 617
#define VMSTATE_INT32_ARRAY_V(_f, _s, _n, _v)                         \
    VMSTATE_ARRAY(_f, _s, _n, _v, vmstate_info_int32, int32_t)

#define VMSTATE_INT32_ARRAY(_f, _s, _n)                               \
    VMSTATE_INT32_ARRAY_V(_f, _s, _n, 0)

618
#define VMSTATE_BUFFER_V(_f, _s, _v)                                  \
619
    VMSTATE_STATIC_BUFFER(_f, _s, _v, NULL, 0, sizeof(typeof_field(_s, _f)))
620 621

#define VMSTATE_BUFFER(_f, _s)                                        \
622 623 624 625 626 627 628
    VMSTATE_BUFFER_V(_f, _s, 0)

#define VMSTATE_PARTIAL_BUFFER(_f, _s, _size)                         \
    VMSTATE_STATIC_BUFFER(_f, _s, 0, NULL, 0, _size)

#define VMSTATE_BUFFER_START_MIDDLE(_f, _s, _start) \
    VMSTATE_STATIC_BUFFER(_f, _s, 0, NULL, _start, sizeof(typeof_field(_s, _f)))
629

630 631
#define VMSTATE_BUFFER_TEST(_f, _s, _test)                            \
    VMSTATE_STATIC_BUFFER(_f, _s, 0, _test, 0, sizeof(typeof_field(_s, _f)))
J
Juan Quintela 已提交
632

J
Juan Quintela 已提交
633 634 635 636 637 638 639 640 641
#define VMSTATE_UNUSED_V(_v, _size)                                   \
    VMSTATE_UNUSED_BUFFER(NULL, _v, _size)

#define VMSTATE_UNUSED(_size)                                         \
    VMSTATE_UNUSED_V(0, _size)

#define VMSTATE_UNUSED_TEST(_test, _size)                             \
    VMSTATE_UNUSED_BUFFER(_test, 0, _size)

J
Juan Quintela 已提交
642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660
#ifdef NEED_CPU_H
#if TARGET_LONG_BITS == 64
#define VMSTATE_UINTTL_V(_f, _s, _v)                                  \
    VMSTATE_UINT64_V(_f, _s, _v)
#define VMSTATE_UINTTL_ARRAY_V(_f, _s, _n, _v)                        \
    VMSTATE_UINT64_ARRAY_V(_f, _s, _n, _v)
#else
#define VMSTATE_UINTTL_V(_f, _s, _v)                                  \
    VMSTATE_UINT32_V(_f, _s, _v)
#define VMSTATE_UINTTL_ARRAY_V(_f, _s, _n, _v)                        \
    VMSTATE_UINT32_ARRAY_V(_f, _s, _n, _v)
#endif
#define VMSTATE_UINTTL(_f, _s)                                        \
    VMSTATE_UINTTL_V(_f, _s, 0)
#define VMSTATE_UINTTL_ARRAY(_f, _s, _n)                              \
    VMSTATE_UINTTL_ARRAY_V(_f, _s, _n, 0)

#endif

661 662 663 664 665 666
#define VMSTATE_END_OF_LIST()                                         \
    {}

extern int vmstate_load_state(QEMUFile *f, const VMStateDescription *vmsd,
                              void *opaque, int version_id);
extern void vmstate_save_state(QEMUFile *f, const VMStateDescription *vmsd,
667
                               void *opaque);
668 669
extern int vmstate_register(int instance_id, const VMStateDescription *vmsd,
                            void *base);
670
void vmstate_unregister(const VMStateDescription *vmsd, void *opaque);
P
pbrook 已提交
671
#endif