From: Anthony Liguori <anthony@codemonkey.ws>
To: Paolo Bonzini <pbonzini@redhat.com>
Cc: qemu-devel@nongnu.org
Subject: Re: [Qemu-devel] [PATCH 2/2] vmstate: extract declarations out of hw/hw.h
Date: Fri, 09 Sep 2011 12:00:38 -0500 [thread overview]
Message-ID: <4E6A4636.4040102@codemonkey.ws> (raw)
In-Reply-To: <1315240017-15648-2-git-send-email-pbonzini@redhat.com>
On 09/05/2011 11:26 AM, Paolo Bonzini wrote:
> Signed-off-by: Paolo Bonzini<pbonzini@redhat.com>
One of these two causes:
CC sparc-softmmu/slavio_timer.o
In file included from /home/anthony/git/qemu/hw/slavio_timer.c:27:0:
/home/anthony/git/qemu/hw/ptimer.h:27:33: error: expected ‘=’, ‘,’, ‘;’,
‘asm’ or ‘__attribute__’ before ‘vmstate_ptimer’
/home/anthony/git/qemu/hw/slavio_timer.c:338:9: error: ‘vmstate_ptimer’
undeclared here (not in a function)
make[1]: *** [slavio_timer.o] Error 1
Regards,
Anthony Liguori
> ---
> hw/hid.h | 23 ++
> hw/hw.h | 882 +----------------------------------------------------------
> hw/i2c.h | 10 +
> hw/pci.h | 18 ++
> hw/pcie.h | 11 +
> hw/ptimer.h | 11 +
> hw/usb.h | 12 +
> net.h | 13 +
> qemu-file.h | 232 ++++++++++++++++
> vmstate.h | 613 +++++++++++++++++++++++++++++++++++++++++
> 10 files changed, 945 insertions(+), 880 deletions(-)
> create mode 100644 qemu-file.h
> create mode 100644 vmstate.h
>
> diff --git a/hw/hid.h b/hw/hid.h
> index 9ce03b1..5315cf7 100644
> --- a/hw/hid.h
> +++ b/hw/hid.h
> @@ -1,6 +1,8 @@
> #ifndef QEMU_HID_H
> #define QEMU_HID_H
>
> +#include "vmstate.h"
> +
> #define HID_MOUSE 1
> #define HID_TABLET 2
> #define HID_KEYBOARD 3
> @@ -56,4 +58,25 @@ int hid_pointer_poll(HIDState *hs, uint8_t *buf, int len);
> int hid_keyboard_poll(HIDState *hs, uint8_t *buf, int len);
> int hid_keyboard_write(HIDState *hs, uint8_t *buf, int len);
>
> +extern const VMStateDescription vmstate_hid_keyboard_device;
> +
> +#define VMSTATE_HID_KEYBOARD_DEVICE(_field, _state) { \
> + .name = (stringify(_field)), \
> + .size = sizeof(HIDState), \
> + .vmsd =&vmstate_hid_keyboard_device, \
> + .flags = VMS_STRUCT, \
> + .offset = vmstate_offset_value(_state, _field, HIDState), \
> +}
> +
> +extern const VMStateDescription vmstate_hid_ptr_device;
> +
> +#define VMSTATE_HID_POINTER_DEVICE(_field, _state) { \
> + .name = (stringify(_field)), \
> + .size = sizeof(HIDState), \
> + .vmsd =&vmstate_hid_ptr_device, \
> + .flags = VMS_STRUCT, \
> + .offset = vmstate_offset_value(_state, _field, HIDState), \
> +}
> +
> +
> #endif /* QEMU_HID_H */
> diff --git a/hw/hw.h b/hw/hw.h
> index a124da9..e5cb9bf 100644
> --- a/hw/hw.h
> +++ b/hw/hw.h
> @@ -10,209 +10,8 @@
>
> #include "ioport.h"
> #include "irq.h"
> -
> -/* VM Load/Save */
> -
> -/* 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.
> - */
> -typedef int (QEMUFilePutBufferFunc)(void *opaque, const uint8_t *buf,
> - int64_t pos, int size);
> -
> -/* 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);
> -
> -/* 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 int64_t (QEMUFileSetRateLimit)(void *opaque, int64_t new_rate);
> -typedef int64_t (QEMUFileGetRateLimit)(void *opaque);
> -
> -QEMUFile *qemu_fopen_ops(void *opaque, QEMUFilePutBufferFunc *put_buffer,
> - QEMUFileGetBufferFunc *get_buffer,
> - QEMUFileCloseFunc *close,
> - QEMUFileRateLimit *rate_limit,
> - QEMUFileSetRateLimit *set_rate_limit,
> - QEMUFileGetRateLimit *get_rate_limit);
> -QEMUFile *qemu_fopen(const char *filename, const char *mode);
> -QEMUFile *qemu_fdopen(int fd, const char *mode);
> -QEMUFile *qemu_fopen_socket(int fd);
> -QEMUFile *qemu_popen(FILE *popen_file, const char *mode);
> -QEMUFile *qemu_popen_cmd(const char *command, const char *mode);
> -int qemu_stdio_fd(QEMUFile *f);
> -void qemu_fflush(QEMUFile *f);
> -int qemu_fclose(QEMUFile *f);
> -void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size);
> -void qemu_put_byte(QEMUFile *f, int v);
> -
> -static inline void qemu_put_ubyte(QEMUFile *f, unsigned int v)
> -{
> - qemu_put_byte(f, (int)v);
> -}
> -
> -#define qemu_put_sbyte qemu_put_byte
> -
> -void qemu_put_be16(QEMUFile *f, unsigned int v);
> -void qemu_put_be32(QEMUFile *f, unsigned int v);
> -void qemu_put_be64(QEMUFile *f, uint64_t v);
> -int qemu_get_buffer(QEMUFile *f, uint8_t *buf, int size);
> -int qemu_get_byte(QEMUFile *f);
> -
> -static inline unsigned int qemu_get_ubyte(QEMUFile *f)
> -{
> - return (unsigned int)qemu_get_byte(f);
> -}
> -
> -#define qemu_get_sbyte qemu_get_byte
> -
> -unsigned int qemu_get_be16(QEMUFile *f);
> -unsigned int qemu_get_be32(QEMUFile *f);
> -uint64_t qemu_get_be64(QEMUFile *f);
> -int qemu_file_rate_limit(QEMUFile *f);
> -int64_t qemu_file_set_rate_limit(QEMUFile *f, int64_t new_rate);
> -int64_t qemu_file_get_rate_limit(QEMUFile *f);
> -int qemu_file_has_error(QEMUFile *f);
> -void qemu_file_set_error(QEMUFile *f);
> -
> -/* 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);
> -
> -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);
> -}
> -
> -// 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);
> -}
> +#include "qemu-file.h"
> +#include "vmstate.h"
>
> #ifdef NEED_CPU_H
> #if TARGET_LONG_BITS == 64
> @@ -236,37 +35,6 @@ static inline void qemu_get_sbe64s(QEMUFile *f, int64_t *pv)
> #endif
> #endif
>
> -int64_t qemu_ftell(QEMUFile *f);
> -int64_t qemu_fseek(QEMUFile *f, int64_t pos, int whence);
> -
> -typedef void SaveSetParamsHandler(int blk_enable, int shared, void * opaque);
> -typedef void SaveStateHandler(QEMUFile *f, void *opaque);
> -typedef int SaveLiveStateHandler(Monitor *mon, QEMUFile *f, int stage,
> - void *opaque);
> -typedef int LoadStateHandler(QEMUFile *f, void *opaque, int version_id);
> -
> -int register_savevm(DeviceState *dev,
> - const char *idstr,
> - int instance_id,
> - int version_id,
> - SaveStateHandler *save_state,
> - LoadStateHandler *load_state,
> - void *opaque);
> -
> -int register_savevm_live(DeviceState *dev,
> - const char *idstr,
> - int instance_id,
> - int version_id,
> - SaveSetParamsHandler *set_params,
> - SaveLiveStateHandler *save_live_state,
> - SaveStateHandler *save_state,
> - LoadStateHandler *load_state,
> - void *opaque);
> -
> -void unregister_savevm(DeviceState *dev, const char *idstr, void *opaque);
> -void register_device_unmigratable(DeviceState *dev, const char *idstr,
> - void *opaque);
> -
> typedef void QEMUResetHandler(void *opaque);
>
> void qemu_register_reset(QEMUResetHandler *func, void *opaque);
> @@ -278,637 +46,6 @@ typedef int QEMUBootSetHandler(void *opaque, const char *boot_devices);
> void qemu_register_boot_set(QEMUBootSetHandler *func, void *opaque);
> int qemu_boot_set(const char *boot_devices);
>
> -typedef struct VMStateInfo VMStateInfo;
> -typedef struct VMStateDescription VMStateDescription;
> -
> -struct VMStateInfo {
> - const char *name;
> - int (*get)(QEMUFile *f, void *pv, size_t size);
> - void (*put)(QEMUFile *f, void *pv, size_t size);
> -};
> -
> -enum VMStateFlags {
> - VMS_SINGLE = 0x001,
> - VMS_POINTER = 0x002,
> - VMS_ARRAY = 0x004,
> - VMS_STRUCT = 0x008,
> - VMS_VARRAY_INT32 = 0x010, /* Array with size in int32_t field*/
> - VMS_BUFFER = 0x020, /* static sized buffer */
> - VMS_ARRAY_OF_POINTER = 0x040,
> - VMS_VARRAY_UINT16 = 0x080, /* Array with size in uint16_t field */
> - VMS_VBUFFER = 0x100, /* Buffer with size in int32_t field */
> - VMS_MULTIPLY = 0x200, /* multiply "size" field by field_size */
> - VMS_VARRAY_UINT8 = 0x400, /* Array with size in uint8_t field*/
> - VMS_VARRAY_UINT32 = 0x800, /* Array with size in uint32_t field*/
> -};
> -
> -typedef struct {
> - const char *name;
> - size_t offset;
> - size_t size;
> - size_t start;
> - int num;
> - size_t num_offset;
> - size_t size_offset;
> - const VMStateInfo *info;
> - enum VMStateFlags flags;
> - const VMStateDescription *vmsd;
> - int version_id;
> - bool (*field_exists)(void *opaque, int version_id);
> -} VMStateField;
> -
> -typedef struct VMStateSubsection {
> - const VMStateDescription *vmsd;
> - bool (*needed)(void *opaque);
> -} VMStateSubsection;
> -
> -struct VMStateDescription {
> - const char *name;
> - int unmigratable;
> - int version_id;
> - int minimum_version_id;
> - int minimum_version_id_old;
> - LoadStateHandler *load_state_old;
> - int (*pre_load)(void *opaque);
> - int (*post_load)(void *opaque, int version_id);
> - void (*pre_save)(void *opaque);
> - VMStateField *fields;
> - const VMStateSubsection *subsections;
> -};
> -
> -extern const VMStateInfo vmstate_info_bool;
> -
> -extern const VMStateInfo vmstate_info_int8;
> -extern const VMStateInfo vmstate_info_int16;
> -extern const VMStateInfo vmstate_info_int32;
> -extern const VMStateInfo vmstate_info_int64;
> -
> -extern const VMStateInfo vmstate_info_uint8_equal;
> -extern const VMStateInfo vmstate_info_uint16_equal;
> -extern const VMStateInfo vmstate_info_int32_equal;
> -extern const VMStateInfo vmstate_info_uint32_equal;
> -extern const VMStateInfo vmstate_info_int32_le;
> -
> -extern const VMStateInfo vmstate_info_uint8;
> -extern const VMStateInfo vmstate_info_uint16;
> -extern const VMStateInfo vmstate_info_uint32;
> -extern const VMStateInfo vmstate_info_uint64;
> -
> -extern const VMStateInfo vmstate_info_timer;
> -extern const VMStateInfo vmstate_info_ptimer;
> -extern const VMStateInfo vmstate_info_buffer;
> -extern const VMStateInfo vmstate_info_unused_buffer;
> -
> -#define type_check_array(t1,t2,n) ((t1(*)[n])0 - (t2*)0)
> -#define type_check_pointer(t1,t2) ((t1**)0 - (t2*)0)
> -
> -#define vmstate_offset_value(_state, _field, _type) \
> - (offsetof(_state, _field) + \
> - type_check(_type, typeof_field(_state, _field)))
> -
> -#define vmstate_offset_pointer(_state, _field, _type) \
> - (offsetof(_state, _field) + \
> - type_check_pointer(_type, typeof_field(_state, _field)))
> -
> -#define vmstate_offset_array(_state, _field, _type, _num) \
> - (offsetof(_state, _field) + \
> - type_check_array(_type, typeof_field(_state, _field), _num))
> -
> -#define vmstate_offset_sub_array(_state, _field, _type, _start) \
> - (offsetof(_state, _field[_start]))
> -
> -#define vmstate_offset_buffer(_state, _field) \
> - vmstate_offset_array(_state, _field, uint8_t, \
> - sizeof(typeof_field(_state, _field)))
> -
> -#define VMSTATE_SINGLE_TEST(_field, _state, _test, _version, _info, _type) { \
> - .name = (stringify(_field)), \
> - .version_id = (_version), \
> - .field_exists = (_test), \
> - .size = sizeof(_type), \
> - .info =&(_info), \
> - .flags = VMS_SINGLE, \
> - .offset = vmstate_offset_value(_state, _field, _type), \
> -}
> -
> -#define VMSTATE_POINTER(_field, _state, _version, _info, _type) { \
> - .name = (stringify(_field)), \
> - .version_id = (_version), \
> - .info =&(_info), \
> - .size = sizeof(_type), \
> - .flags = VMS_SINGLE|VMS_POINTER, \
> - .offset = vmstate_offset_value(_state, _field, _type), \
> -}
> -
> -#define VMSTATE_POINTER_TEST(_field, _state, _test, _info, _type) { \
> - .name = (stringify(_field)), \
> - .info =&(_info), \
> - .field_exists = (_test), \
> - .size = sizeof(_type), \
> - .flags = VMS_SINGLE|VMS_POINTER, \
> - .offset = vmstate_offset_value(_state, _field, _type), \
> -}
> -
> -#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, \
> - .offset = vmstate_offset_array(_state, _field, _type, _num), \
> -}
> -
> -#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, \
> - .offset = vmstate_offset_array(_state, _field, _type, _num),\
> -}
> -
> -#define VMSTATE_SUB_ARRAY(_field, _state, _start, _num, _version, _info, _type) { \
> - .name = (stringify(_field)), \
> - .version_id = (_version), \
> - .num = (_num), \
> - .info =&(_info), \
> - .size = sizeof(_type), \
> - .flags = VMS_ARRAY, \
> - .offset = vmstate_offset_sub_array(_state, _field, _type, _start), \
> -}
> -
> -#define VMSTATE_ARRAY_INT32_UNSAFE(_field, _state, _field_num, _info, _type) {\
> - .name = (stringify(_field)), \
> - .num_offset = vmstate_offset_value(_state, _field_num, int32_t), \
> - .info =&(_info), \
> - .size = sizeof(_type), \
> - .flags = VMS_VARRAY_INT32, \
> - .offset = offsetof(_state, _field), \
> -}
> -
> -#define VMSTATE_VARRAY_INT32(_field, _state, _field_num, _version, _info, _type) {\
> - .name = (stringify(_field)), \
> - .version_id = (_version), \
> - .num_offset = vmstate_offset_value(_state, _field_num, int32_t), \
> - .info =&(_info), \
> - .size = sizeof(_type), \
> - .flags = VMS_VARRAY_INT32|VMS_POINTER, \
> - .offset = vmstate_offset_pointer(_state, _field, _type), \
> -}
> -
> -#define VMSTATE_VARRAY_UINT32(_field, _state, _field_num, _version, _info, _type) {\
> - .name = (stringify(_field)), \
> - .version_id = (_version), \
> - .num_offset = vmstate_offset_value(_state, _field_num, uint32_t),\
> - .info =&(_info), \
> - .size = sizeof(_type), \
> - .flags = VMS_VARRAY_UINT32|VMS_POINTER, \
> - .offset = vmstate_offset_pointer(_state, _field, _type), \
> -}
> -
> -#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), \
> -}
> -
> -#define VMSTATE_STRUCT_TEST(_field, _state, _test, _version, _vmsd, _type) { \
> - .name = (stringify(_field)), \
> - .version_id = (_version), \
> - .field_exists = (_test), \
> - .vmsd =&(_vmsd), \
> - .size = sizeof(_type), \
> - .flags = VMS_STRUCT, \
> - .offset = vmstate_offset_value(_state, _field, _type), \
> -}
> -
> -#define VMSTATE_STRUCT_POINTER_TEST(_field, _state, _test, _vmsd, _type) { \
> - .name = (stringify(_field)), \
> - .field_exists = (_test), \
> - .vmsd =&(_vmsd), \
> - .size = sizeof(_type), \
> - .flags = VMS_STRUCT|VMS_POINTER, \
> - .offset = vmstate_offset_value(_state, _field, _type), \
> -}
> -
> -#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, \
> - .offset = vmstate_offset_array(_state, _field, _type, _num), \
> -}
> -
> -#define VMSTATE_STRUCT_ARRAY_TEST(_field, _state, _num, _test, _version, _vmsd, _type) { \
> - .name = (stringify(_field)), \
> - .num = (_num), \
> - .field_exists = (_test), \
> - .version_id = (_version), \
> - .vmsd =&(_vmsd), \
> - .size = sizeof(_type), \
> - .flags = VMS_STRUCT|VMS_ARRAY, \
> - .offset = vmstate_offset_array(_state, _field, _type, _num),\
> -}
> -
> -#define VMSTATE_STRUCT_VARRAY_UINT8(_field, _state, _field_num, _version, _vmsd, _type) { \
> - .name = (stringify(_field)), \
> - .num_offset = vmstate_offset_value(_state, _field_num, uint8_t), \
> - .version_id = (_version), \
> - .vmsd =&(_vmsd), \
> - .size = sizeof(_type), \
> - .flags = VMS_STRUCT|VMS_VARRAY_UINT8, \
> - .offset = offsetof(_state, _field), \
> -}
> -
> -#define VMSTATE_STRUCT_VARRAY_POINTER_INT32(_field, _state, _field_num, _vmsd, _type) { \
> - .name = (stringify(_field)), \
> - .version_id = 0, \
> - .num_offset = vmstate_offset_value(_state, _field_num, int32_t), \
> - .size = sizeof(_type), \
> - .vmsd =&(_vmsd), \
> - .flags = VMS_POINTER | VMS_VARRAY_INT32 | VMS_STRUCT, \
> - .offset = vmstate_offset_pointer(_state, _field, _type), \
> -}
> -
> -#define VMSTATE_STRUCT_VARRAY_POINTER_UINT16(_field, _state, _field_num, _vmsd, _type) { \
> - .name = (stringify(_field)), \
> - .version_id = 0, \
> - .num_offset = vmstate_offset_value(_state, _field_num, uint16_t),\
> - .size = sizeof(_type), \
> - .vmsd =&(_vmsd), \
> - .flags = VMS_POINTER | VMS_VARRAY_UINT16 | VMS_STRUCT, \
> - .offset = vmstate_offset_pointer(_state, _field, _type), \
> -}
> -
> -#define VMSTATE_STRUCT_VARRAY_INT32(_field, _state, _field_num, _version, _vmsd, _type) { \
> - .name = (stringify(_field)), \
> - .num_offset = vmstate_offset_value(_state, _field_num, int32_t), \
> - .version_id = (_version), \
> - .vmsd =&(_vmsd), \
> - .size = sizeof(_type), \
> - .flags = VMS_STRUCT|VMS_VARRAY_INT32, \
> - .offset = offsetof(_state, _field), \
> -}
> -
> -#define VMSTATE_STRUCT_VARRAY_UINT32(_field, _state, _field_num, _version, _vmsd, _type) { \
> - .name = (stringify(_field)), \
> - .num_offset = vmstate_offset_value(_state, _field_num, uint32_t), \
> - .version_id = (_version), \
> - .vmsd =&(_vmsd), \
> - .size = sizeof(_type), \
> - .flags = VMS_STRUCT|VMS_VARRAY_UINT32, \
> - .offset = offsetof(_state, _field), \
> -}
> -
> -#define VMSTATE_STATIC_BUFFER(_field, _state, _version, _test, _start, _size) { \
> - .name = (stringify(_field)), \
> - .version_id = (_version), \
> - .field_exists = (_test), \
> - .size = (_size - _start), \
> - .info =&vmstate_info_buffer, \
> - .flags = VMS_BUFFER, \
> - .offset = vmstate_offset_buffer(_state, _field) + _start, \
> -}
> -
> -#define VMSTATE_BUFFER_MULTIPLY(_field, _state, _version, _test, _start, _field_size, _multiply) { \
> - .name = (stringify(_field)), \
> - .version_id = (_version), \
> - .field_exists = (_test), \
> - .size_offset = vmstate_offset_value(_state, _field_size, uint32_t),\
> - .size = (_multiply), \
> - .info =&vmstate_info_buffer, \
> - .flags = VMS_VBUFFER|VMS_MULTIPLY, \
> - .offset = offsetof(_state, _field), \
> - .start = (_start), \
> -}
> -
> -#define VMSTATE_VBUFFER(_field, _state, _version, _test, _start, _field_size) { \
> - .name = (stringify(_field)), \
> - .version_id = (_version), \
> - .field_exists = (_test), \
> - .size_offset = vmstate_offset_value(_state, _field_size, int32_t),\
> - .info =&vmstate_info_buffer, \
> - .flags = VMS_VBUFFER|VMS_POINTER, \
> - .offset = offsetof(_state, _field), \
> - .start = (_start), \
> -}
> -
> -#define VMSTATE_VBUFFER_UINT32(_field, _state, _version, _test, _start, _field_size) { \
> - .name = (stringify(_field)), \
> - .version_id = (_version), \
> - .field_exists = (_test), \
> - .size_offset = vmstate_offset_value(_state, _field_size, uint32_t),\
> - .info =&vmstate_info_buffer, \
> - .flags = VMS_VBUFFER|VMS_POINTER, \
> - .offset = offsetof(_state, _field), \
> - .start = (_start), \
> -}
> -
> -#define VMSTATE_BUFFER_UNSAFE_INFO(_field, _state, _version, _info, _size) { \
> - .name = (stringify(_field)), \
> - .version_id = (_version), \
> - .size = (_size), \
> - .info =&(_info), \
> - .flags = VMS_BUFFER, \
> - .offset = offsetof(_state, _field), \
> -}
> -
> -#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, \
> -}
> -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, \
> - .offset = vmstate_offset_value(_state, _field, PCIDevice), \
> -}
> -
> -#define VMSTATE_PCI_DEVICE_POINTER(_field, _state) { \
> - .name = (stringify(_field)), \
> - .size = sizeof(PCIDevice), \
> - .vmsd =&vmstate_pci_device, \
> - .flags = VMS_STRUCT|VMS_POINTER, \
> - .offset = vmstate_offset_pointer(_state, _field, PCIDevice), \
> -}
> -
> -extern const VMStateDescription vmstate_pcie_device;
> -
> -#define VMSTATE_PCIE_DEVICE(_field, _state) { \
> - .name = (stringify(_field)), \
> - .version_id = 2, \
> - .size = sizeof(PCIDevice), \
> - .vmsd =&vmstate_pcie_device, \
> - .flags = VMS_STRUCT, \
> - .offset = vmstate_offset_value(_state, _field, PCIDevice), \
> -}
> -
> -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, \
> - .offset = vmstate_offset_value(_state, _field, i2c_slave), \
> -}
> -
> -extern const VMStateDescription vmstate_usb_device;
> -
> -#define VMSTATE_USB_DEVICE(_field, _state) { \
> - .name = (stringify(_field)), \
> - .size = sizeof(USBDevice), \
> - .vmsd =&vmstate_usb_device, \
> - .flags = VMS_STRUCT, \
> - .offset = vmstate_offset_value(_state, _field, USBDevice), \
> -}
> -
> -#define vmstate_offset_macaddr(_state, _field) \
> - vmstate_offset_array(_state, _field.a, uint8_t, \
> - sizeof(typeof_field(_state, _field)))
> -
> -#define VMSTATE_MACADDR(_field, _state) { \
> - .name = (stringify(_field)), \
> - .size = sizeof(MACAddr), \
> - .info =&vmstate_info_buffer, \
> - .flags = VMS_BUFFER, \
> - .offset = vmstate_offset_macaddr(_state, _field), \
> -}
> -
> -extern const VMStateDescription vmstate_ptimer;
> -
> -#define VMSTATE_PTIMER(_field, _state) { \
> - .name = (stringify(_field)), \
> - .version_id = (1), \
> - .vmsd =&vmstate_ptimer, \
> - .size = sizeof(ptimer_state *), \
> - .flags = VMS_STRUCT|VMS_POINTER, \
> - .offset = vmstate_offset_pointer(_state, _field, ptimer_state), \
> -}
> -
> -extern const VMStateDescription vmstate_hid_keyboard_device;
> -
> -#define VMSTATE_HID_KEYBOARD_DEVICE(_field, _state) { \
> - .name = (stringify(_field)), \
> - .size = sizeof(HIDState), \
> - .vmsd =&vmstate_hid_keyboard_device, \
> - .flags = VMS_STRUCT, \
> - .offset = vmstate_offset_value(_state, _field, HIDState), \
> -}
> -
> -extern const VMStateDescription vmstate_hid_ptr_device;
> -
> -#define VMSTATE_HID_POINTER_DEVICE(_field, _state) { \
> - .name = (stringify(_field)), \
> - .size = sizeof(HIDState), \
> - .vmsd =&vmstate_hid_ptr_device, \
> - .flags = VMS_STRUCT, \
> - .offset = vmstate_offset_value(_state, _field, HIDState), \
> -}
> -
> -/* _f : field name
> - _f_n : num of elements field_name
> - _n : num of elements
> - _s : struct state name
> - _v : version
> -*/
> -
> -#define VMSTATE_SINGLE(_field, _state, _version, _info, _type) \
> - VMSTATE_SINGLE_TEST(_field, _state, NULL, _version, _info, _type)
> -
> -#define VMSTATE_STRUCT(_field, _state, _version, _vmsd, _type) \
> - VMSTATE_STRUCT_TEST(_field, _state, NULL, _version, _vmsd, _type)
> -
> -#define VMSTATE_STRUCT_POINTER(_field, _state, _vmsd, _type) \
> - VMSTATE_STRUCT_POINTER_TEST(_field, _state, NULL, _vmsd, _type)
> -
> -#define VMSTATE_STRUCT_ARRAY(_field, _state, _num, _version, _vmsd, _type) \
> - VMSTATE_STRUCT_ARRAY_TEST(_field, _state, _num, NULL, _version, \
> - _vmsd, _type)
> -
> -#define VMSTATE_BOOL_V(_f, _s, _v) \
> - VMSTATE_SINGLE(_f, _s, _v, vmstate_info_bool, bool)
> -
> -#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_BOOL(_f, _s) \
> - VMSTATE_BOOL_V(_f, _s, 0)
> -
> -#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)
> -
> -#define VMSTATE_UINT8_EQUAL(_f, _s) \
> - VMSTATE_SINGLE(_f, _s, 0, vmstate_info_uint8_equal, uint8_t)
> -
> -#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)
> -
> -#define VMSTATE_INT32_EQUAL(_f, _s) \
> - VMSTATE_SINGLE(_f, _s, 0, vmstate_info_int32_equal, int32_t)
> -
> -#define VMSTATE_UINT32_EQUAL(_f, _s) \
> - VMSTATE_SINGLE(_f, _s, 0, vmstate_info_uint32_equal, uint32_t)
> -
> -#define VMSTATE_INT32_LE(_f, _s) \
> - VMSTATE_SINGLE(_f, _s, 0, vmstate_info_int32_le, int32_t)
> -
> -#define VMSTATE_UINT8_TEST(_f, _s, _t) \
> - VMSTATE_SINGLE_TEST(_f, _s, _t, 0, vmstate_info_uint8, uint8_t)
> -
> -#define VMSTATE_UINT16_TEST(_f, _s, _t) \
> - VMSTATE_SINGLE_TEST(_f, _s, _t, 0, vmstate_info_uint16, uint16_t)
> -
> -#define VMSTATE_UINT32_TEST(_f, _s, _t) \
> - VMSTATE_SINGLE_TEST(_f, _s, _t, 0, vmstate_info_uint32, uint32_t)
> -
> -#define VMSTATE_TIMER_TEST(_f, _s, _test) \
> - VMSTATE_POINTER_TEST(_f, _s, _test, vmstate_info_timer, QEMUTimer *)
> -
> -#define VMSTATE_TIMER(_f, _s) \
> - VMSTATE_TIMER_TEST(_f, _s, NULL)
> -
> -#define VMSTATE_TIMER_ARRAY(_f, _s, _n) \
> - VMSTATE_ARRAY_OF_POINTER(_f, _s, _n, 0, vmstate_info_timer, QEMUTimer *)
> -
> -#define VMSTATE_BOOL_ARRAY_V(_f, _s, _n, _v) \
> - VMSTATE_ARRAY(_f, _s, _n, _v, vmstate_info_bool, bool)
> -
> -#define VMSTATE_BOOL_ARRAY(_f, _s, _n) \
> - VMSTATE_BOOL_ARRAY_V(_f, _s, _n, 0)
> -
> -#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)
> -
> -#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)
> -
> -#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)
> -
> -#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)
> -
> -#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)
> -
> -#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)
> -
> -#define VMSTATE_UINT32_SUB_ARRAY(_f, _s, _start, _num) \
> - VMSTATE_SUB_ARRAY(_f, _s, _start, _num, 0, vmstate_info_uint32, uint32_t)
> -
> -#define VMSTATE_UINT32_ARRAY(_f, _s, _n) \
> - VMSTATE_UINT32_ARRAY_V(_f, _s, _n, 0)
> -
> -#define VMSTATE_INT64_ARRAY_V(_f, _s, _n, _v) \
> - VMSTATE_ARRAY(_f, _s, _n, _v, vmstate_info_int64, int64_t)
> -
> -#define VMSTATE_INT64_ARRAY(_f, _s, _n) \
> - VMSTATE_INT64_ARRAY_V(_f, _s, _n, 0)
> -
> -#define VMSTATE_BUFFER_V(_f, _s, _v) \
> - VMSTATE_STATIC_BUFFER(_f, _s, _v, NULL, 0, sizeof(typeof_field(_s, _f)))
> -
> -#define VMSTATE_BUFFER(_f, _s) \
> - 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)))
> -
> -#define VMSTATE_PARTIAL_VBUFFER(_f, _s, _size) \
> - VMSTATE_VBUFFER(_f, _s, 0, NULL, 0, _size)
> -
> -#define VMSTATE_PARTIAL_VBUFFER_UINT32(_f, _s, _size) \
> - VMSTATE_VBUFFER_UINT32(_f, _s, 0, NULL, 0, _size)
> -
> -#define VMSTATE_SUB_VBUFFER(_f, _s, _start, _size) \
> - VMSTATE_VBUFFER(_f, _s, 0, NULL, _start, _size)
> -
> -#define VMSTATE_BUFFER_TEST(_f, _s, _test) \
> - VMSTATE_STATIC_BUFFER(_f, _s, 0, _test, 0, sizeof(typeof_field(_s, _f)))
> -
> -#define VMSTATE_BUFFER_UNSAFE(_field, _state, _version, _size) \
> - VMSTATE_BUFFER_UNSAFE_INFO(_field, _state, _version, vmstate_info_buffer, _size)
> -
> -#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)
> -
> #ifdef NEED_CPU_H
> #if TARGET_LONG_BITS == 64
> #define VMSTATE_UINTTL_V(_f, _s, _v) \
> @@ -928,19 +65,4 @@ extern const VMStateDescription vmstate_hid_ptr_device;
>
> #endif
>
> -#define VMSTATE_END_OF_LIST() \
> - {}
> -
> -int vmstate_load_state(QEMUFile *f, const VMStateDescription *vmsd,
> - void *opaque, int version_id);
> -void vmstate_save_state(QEMUFile *f, const VMStateDescription *vmsd,
> - void *opaque);
> -int vmstate_register(DeviceState *dev, int instance_id,
> - const VMStateDescription *vmsd, void *base);
> -int vmstate_register_with_alias_id(DeviceState *dev, int instance_id,
> - const VMStateDescription *vmsd,
> - void *base, int alias_id,
> - int required_for_version);
> -void vmstate_unregister(DeviceState *dev, const VMStateDescription *vmsd,
> - void *opaque);
> #endif
> diff --git a/hw/i2c.h b/hw/i2c.h
> index 9381d01..a3383ff 100644
> --- a/hw/i2c.h
> +++ b/hw/i2c.h
> @@ -74,4 +74,14 @@ void tmp105_set(i2c_slave *i2c, int temp);
> /* lm832x.c */
> void lm832x_key_event(DeviceState *dev, int key, int state);
>
> +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, \
> + .offset = vmstate_offset_value(_state, _field, i2c_slave), \
> +}
> +
> #endif
> diff --git a/hw/pci.h b/hw/pci.h
> index 391217e..151b385 100644
> --- a/hw/pci.h
> +++ b/hw/pci.h
> @@ -492,4 +492,22 @@ static inline uint32_t pci_config_size(const PCIDevice *d)
> return pci_is_express(d) ? PCIE_CONFIG_SPACE_SIZE : PCI_CONFIG_SPACE_SIZE;
> }
>
> +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, \
> + .offset = vmstate_offset_value(_state, _field, PCIDevice), \
> +}
> +
> +#define VMSTATE_PCI_DEVICE_POINTER(_field, _state) { \
> + .name = (stringify(_field)), \
> + .size = sizeof(PCIDevice), \
> + .vmsd =&vmstate_pci_device, \
> + .flags = VMS_STRUCT|VMS_POINTER, \
> + .offset = vmstate_offset_pointer(_state, _field, PCIDevice), \
> +}
> +
> #endif
> diff --git a/hw/pcie.h b/hw/pcie.h
> index a213fba..b8ab0c7 100644
> --- a/hw/pcie.h
> +++ b/hw/pcie.h
> @@ -129,4 +129,15 @@ void pcie_add_capability(PCIDevice *dev,
>
> void pcie_ari_init(PCIDevice *dev, uint16_t offset, uint16_t nextfn);
>
> +extern const VMStateDescription vmstate_pcie_device;
> +
> +#define VMSTATE_PCIE_DEVICE(_field, _state) { \
> + .name = (stringify(_field)), \
> + .version_id = 2, \
> + .size = sizeof(PCIDevice), \
> + .vmsd =&vmstate_pcie_device, \
> + .flags = VMS_STRUCT, \
> + .offset = vmstate_offset_value(_state, _field, PCIDevice), \
> +}
> +
> #endif /* QEMU_PCIE_H */
> diff --git a/hw/ptimer.h b/hw/ptimer.h
> index 69cdddc..e7542e4 100644
> --- a/hw/ptimer.h
> +++ b/hw/ptimer.h
> @@ -24,4 +24,15 @@ void ptimer_set_count(ptimer_state *s, uint64_t count);
> void ptimer_run(ptimer_state *s, int oneshot);
> void ptimer_stop(ptimer_state *s);
>
> +extern const VMStateDescription vmstate_ptimer;
> +
> +#define VMSTATE_PTIMER(_field, _state) { \
> + .name = (stringify(_field)), \
> + .version_id = (1), \
> + .vmsd =&vmstate_ptimer, \
> + .size = sizeof(ptimer_state *), \
> + .flags = VMS_STRUCT|VMS_POINTER, \
> + .offset = vmstate_offset_pointer(_state, _field, ptimer_state), \
> +}
> +
> #endif
> diff --git a/hw/usb.h b/hw/usb.h
> index d784448..bc34c97 100644
> --- a/hw/usb.h
> +++ b/hw/usb.h
> @@ -386,3 +386,15 @@ static inline USBBus *usb_bus_from_device(USBDevice *d)
> {
> return DO_UPCAST(USBBus, qbus, d->qdev.parent_bus);
> }
> +
> +extern const VMStateDescription vmstate_usb_device;
> +
> +#define VMSTATE_USB_DEVICE(_field, _state) { \
> + .name = (stringify(_field)), \
> + .size = sizeof(USBDevice), \
> + .vmsd =&vmstate_usb_device, \
> + .flags = VMS_STRUCT, \
> + .offset = vmstate_offset_value(_state, _field, USBDevice), \
> +}
> +
> +
> diff --git a/net.h b/net.h
> index 9f633f8..c1b8b7d 100644
> --- a/net.h
> +++ b/net.h
> @@ -6,6 +6,7 @@
> #include "qdict.h"
> #include "qemu-option.h"
> #include "net/queue.h"
> +#include "vmstate.h"
>
> struct MACAddr {
> uint8_t a[6];
> @@ -179,4 +180,16 @@ void qdev_set_nic_properties(DeviceState *dev, NICInfo *nd);
>
> int net_handle_fd_param(Monitor *mon, const char *param);
>
> +#define vmstate_offset_macaddr(_state, _field) \
> + vmstate_offset_array(_state, _field.a, uint8_t, \
> + sizeof(typeof_field(_state, _field)))
> +
> +#define VMSTATE_MACADDR(_field, _state) { \
> + .name = (stringify(_field)), \
> + .size = sizeof(MACAddr), \
> + .info =&vmstate_info_buffer, \
> + .flags = VMS_BUFFER, \
> + .offset = vmstate_offset_macaddr(_state, _field), \
> +}
> +
> #endif
> diff --git a/qemu-file.h b/qemu-file.h
> new file mode 100644
> index 0000000..40b8fde
> --- /dev/null
> +++ b/qemu-file.h
> @@ -0,0 +1,232 @@
> +/*
> + * QEMU System Emulator
> + *
> + * Copyright (c) 2003-2008 Fabrice Bellard
> + *
> + * Permission is hereby granted, free of charge, to any person obtaining a copy
> + * of this software and associated documentation files (the "Software"), to deal
> + * in the Software without restriction, including without limitation the rights
> + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
> + * copies of the Software, and to permit persons to whom the Software is
> + * furnished to do so, subject to the following conditions:
> + *
> + * The above copyright notice and this permission notice shall be included in
> + * all copies or substantial portions of the Software.
> + *
> + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
> + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
> + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
> + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
> + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
> + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
> + * THE SOFTWARE.
> + */
> +#ifndef QEMU_FILE_H
> +#define QEMU_FILE_H 1
> +
> +/* 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.
> + */
> +typedef int (QEMUFilePutBufferFunc)(void *opaque, const uint8_t *buf,
> + int64_t pos, int size);
> +
> +/* 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);
> +
> +/* 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 int64_t (QEMUFileSetRateLimit)(void *opaque, int64_t new_rate);
> +typedef int64_t (QEMUFileGetRateLimit)(void *opaque);
> +
> +QEMUFile *qemu_fopen_ops(void *opaque, QEMUFilePutBufferFunc *put_buffer,
> + QEMUFileGetBufferFunc *get_buffer,
> + QEMUFileCloseFunc *close,
> + QEMUFileRateLimit *rate_limit,
> + QEMUFileSetRateLimit *set_rate_limit,
> + QEMUFileGetRateLimit *get_rate_limit);
> +QEMUFile *qemu_fopen(const char *filename, const char *mode);
> +QEMUFile *qemu_fdopen(int fd, const char *mode);
> +QEMUFile *qemu_fopen_socket(int fd);
> +QEMUFile *qemu_popen(FILE *popen_file, const char *mode);
> +QEMUFile *qemu_popen_cmd(const char *command, const char *mode);
> +int qemu_stdio_fd(QEMUFile *f);
> +void qemu_fflush(QEMUFile *f);
> +int qemu_fclose(QEMUFile *f);
> +void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size);
> +void qemu_put_byte(QEMUFile *f, int v);
> +
> +static inline void qemu_put_ubyte(QEMUFile *f, unsigned int v)
> +{
> + qemu_put_byte(f, (int)v);
> +}
> +
> +#define qemu_put_sbyte qemu_put_byte
> +
> +void qemu_put_be16(QEMUFile *f, unsigned int v);
> +void qemu_put_be32(QEMUFile *f, unsigned int v);
> +void qemu_put_be64(QEMUFile *f, uint64_t v);
> +int qemu_get_buffer(QEMUFile *f, uint8_t *buf, int size);
> +int qemu_get_byte(QEMUFile *f);
> +
> +static inline unsigned int qemu_get_ubyte(QEMUFile *f)
> +{
> + return (unsigned int)qemu_get_byte(f);
> +}
> +
> +#define qemu_get_sbyte qemu_get_byte
> +
> +unsigned int qemu_get_be16(QEMUFile *f);
> +unsigned int qemu_get_be32(QEMUFile *f);
> +uint64_t qemu_get_be64(QEMUFile *f);
> +
> +int qemu_file_rate_limit(QEMUFile *f);
> +int64_t qemu_file_set_rate_limit(QEMUFile *f, int64_t new_rate);
> +int64_t qemu_file_get_rate_limit(QEMUFile *f);
> +int qemu_file_has_error(QEMUFile *f);
> +void qemu_file_set_error(QEMUFile *f);
> +
> +/* 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);
> +
> +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);
> +}
> +
> +// 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);
> +}
> +
> +int64_t qemu_ftell(QEMUFile *f);
> +int64_t qemu_fseek(QEMUFile *f, int64_t pos, int whence);
> +
> +#endif
> diff --git a/vmstate.h b/vmstate.h
> new file mode 100644
> index 0000000..038b9ac
> --- /dev/null
> +++ b/vmstate.h
> @@ -0,0 +1,613 @@
> +/*
> + * QEMU migration/snapshot declarations
> + *
> + * Copyright (c) 2009-2011 Red Hat, Inc.
> + *
> + * Original author: Juan Quintela<quintela@redhat.com>
> + *
> + * Permission is hereby granted, free of charge, to any person obtaining a copy
> + * of this software and associated documentation files (the "Software"), to deal
> + * in the Software without restriction, including without limitation the rights
> + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
> + * copies of the Software, and to permit persons to whom the Software is
> + * furnished to do so, subject to the following conditions:
> + *
> + * The above copyright notice and this permission notice shall be included in
> + * all copies or substantial portions of the Software.
> + *
> + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
> + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
> + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
> + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
> + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
> + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
> + * THE SOFTWARE.
> + */
> +#ifndef QEMU_VMSTATE_H
> +#define QEMU_VMSTATE_H 1
> +
> +typedef void SaveSetParamsHandler(int blk_enable, int shared, void * opaque);
> +typedef void SaveStateHandler(QEMUFile *f, void *opaque);
> +typedef int SaveLiveStateHandler(Monitor *mon, QEMUFile *f, int stage,
> + void *opaque);
> +typedef int LoadStateHandler(QEMUFile *f, void *opaque, int version_id);
> +
> +int register_savevm(DeviceState *dev,
> + const char *idstr,
> + int instance_id,
> + int version_id,
> + SaveStateHandler *save_state,
> + LoadStateHandler *load_state,
> + void *opaque);
> +
> +int register_savevm_live(DeviceState *dev,
> + const char *idstr,
> + int instance_id,
> + int version_id,
> + SaveSetParamsHandler *set_params,
> + SaveLiveStateHandler *save_live_state,
> + SaveStateHandler *save_state,
> + LoadStateHandler *load_state,
> + void *opaque);
> +
> +void unregister_savevm(DeviceState *dev, const char *idstr, void *opaque);
> +void register_device_unmigratable(DeviceState *dev, const char *idstr,
> + void *opaque);
> +
> +
> +typedef struct VMStateInfo VMStateInfo;
> +typedef struct VMStateDescription VMStateDescription;
> +
> +struct VMStateInfo {
> + const char *name;
> + int (*get)(QEMUFile *f, void *pv, size_t size);
> + void (*put)(QEMUFile *f, void *pv, size_t size);
> +};
> +
> +enum VMStateFlags {
> + VMS_SINGLE = 0x001,
> + VMS_POINTER = 0x002,
> + VMS_ARRAY = 0x004,
> + VMS_STRUCT = 0x008,
> + VMS_VARRAY_INT32 = 0x010, /* Array with size in int32_t field*/
> + VMS_BUFFER = 0x020, /* static sized buffer */
> + VMS_ARRAY_OF_POINTER = 0x040,
> + VMS_VARRAY_UINT16 = 0x080, /* Array with size in uint16_t field */
> + VMS_VBUFFER = 0x100, /* Buffer with size in int32_t field */
> + VMS_MULTIPLY = 0x200, /* multiply "size" field by field_size */
> + VMS_VARRAY_UINT8 = 0x400, /* Array with size in uint8_t field*/
> + VMS_VARRAY_UINT32 = 0x800, /* Array with size in uint32_t field*/
> +};
> +
> +typedef struct {
> + const char *name;
> + size_t offset;
> + size_t size;
> + size_t start;
> + int num;
> + size_t num_offset;
> + size_t size_offset;
> + const VMStateInfo *info;
> + enum VMStateFlags flags;
> + const VMStateDescription *vmsd;
> + int version_id;
> + bool (*field_exists)(void *opaque, int version_id);
> +} VMStateField;
> +
> +typedef struct VMStateSubsection {
> + const VMStateDescription *vmsd;
> + bool (*needed)(void *opaque);
> +} VMStateSubsection;
> +
> +struct VMStateDescription {
> + const char *name;
> + int unmigratable;
> + int version_id;
> + int minimum_version_id;
> + int minimum_version_id_old;
> + LoadStateHandler *load_state_old;
> + int (*pre_load)(void *opaque);
> + int (*post_load)(void *opaque, int version_id);
> + void (*pre_save)(void *opaque);
> + VMStateField *fields;
> + const VMStateSubsection *subsections;
> +};
> +
> +extern const VMStateInfo vmstate_info_bool;
> +
> +extern const VMStateInfo vmstate_info_int8;
> +extern const VMStateInfo vmstate_info_int16;
> +extern const VMStateInfo vmstate_info_int32;
> +extern const VMStateInfo vmstate_info_int64;
> +
> +extern const VMStateInfo vmstate_info_uint8_equal;
> +extern const VMStateInfo vmstate_info_uint16_equal;
> +extern const VMStateInfo vmstate_info_int32_equal;
> +extern const VMStateInfo vmstate_info_uint32_equal;
> +extern const VMStateInfo vmstate_info_int32_le;
> +
> +extern const VMStateInfo vmstate_info_uint8;
> +extern const VMStateInfo vmstate_info_uint16;
> +extern const VMStateInfo vmstate_info_uint32;
> +extern const VMStateInfo vmstate_info_uint64;
> +
> +extern const VMStateInfo vmstate_info_timer;
> +extern const VMStateInfo vmstate_info_buffer;
> +extern const VMStateInfo vmstate_info_unused_buffer;
> +
> +#define type_check_array(t1,t2,n) ((t1(*)[n])0 - (t2*)0)
> +#define type_check_pointer(t1,t2) ((t1**)0 - (t2*)0)
> +
> +#define vmstate_offset_value(_state, _field, _type) \
> + (offsetof(_state, _field) + \
> + type_check(_type, typeof_field(_state, _field)))
> +
> +#define vmstate_offset_pointer(_state, _field, _type) \
> + (offsetof(_state, _field) + \
> + type_check_pointer(_type, typeof_field(_state, _field)))
> +
> +#define vmstate_offset_array(_state, _field, _type, _num) \
> + (offsetof(_state, _field) + \
> + type_check_array(_type, typeof_field(_state, _field), _num))
> +
> +#define vmstate_offset_sub_array(_state, _field, _type, _start) \
> + (offsetof(_state, _field[_start]))
> +
> +#define vmstate_offset_buffer(_state, _field) \
> + vmstate_offset_array(_state, _field, uint8_t, \
> + sizeof(typeof_field(_state, _field)))
> +
> +#define VMSTATE_SINGLE_TEST(_field, _state, _test, _version, _info, _type) { \
> + .name = (stringify(_field)), \
> + .version_id = (_version), \
> + .field_exists = (_test), \
> + .size = sizeof(_type), \
> + .info =&(_info), \
> + .flags = VMS_SINGLE, \
> + .offset = vmstate_offset_value(_state, _field, _type), \
> +}
> +
> +#define VMSTATE_POINTER(_field, _state, _version, _info, _type) { \
> + .name = (stringify(_field)), \
> + .version_id = (_version), \
> + .info =&(_info), \
> + .size = sizeof(_type), \
> + .flags = VMS_SINGLE|VMS_POINTER, \
> + .offset = vmstate_offset_value(_state, _field, _type), \
> +}
> +
> +#define VMSTATE_POINTER_TEST(_field, _state, _test, _info, _type) { \
> + .name = (stringify(_field)), \
> + .info =&(_info), \
> + .field_exists = (_test), \
> + .size = sizeof(_type), \
> + .flags = VMS_SINGLE|VMS_POINTER, \
> + .offset = vmstate_offset_value(_state, _field, _type), \
> +}
> +
> +#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, \
> + .offset = vmstate_offset_array(_state, _field, _type, _num), \
> +}
> +
> +#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, \
> + .offset = vmstate_offset_array(_state, _field, _type, _num),\
> +}
> +
> +#define VMSTATE_SUB_ARRAY(_field, _state, _start, _num, _version, _info, _type) { \
> + .name = (stringify(_field)), \
> + .version_id = (_version), \
> + .num = (_num), \
> + .info =&(_info), \
> + .size = sizeof(_type), \
> + .flags = VMS_ARRAY, \
> + .offset = vmstate_offset_sub_array(_state, _field, _type, _start), \
> +}
> +
> +#define VMSTATE_ARRAY_INT32_UNSAFE(_field, _state, _field_num, _info, _type) {\
> + .name = (stringify(_field)), \
> + .num_offset = vmstate_offset_value(_state, _field_num, int32_t), \
> + .info =&(_info), \
> + .size = sizeof(_type), \
> + .flags = VMS_VARRAY_INT32, \
> + .offset = offsetof(_state, _field), \
> +}
> +
> +#define VMSTATE_VARRAY_INT32(_field, _state, _field_num, _version, _info, _type) {\
> + .name = (stringify(_field)), \
> + .version_id = (_version), \
> + .num_offset = vmstate_offset_value(_state, _field_num, int32_t), \
> + .info =&(_info), \
> + .size = sizeof(_type), \
> + .flags = VMS_VARRAY_INT32|VMS_POINTER, \
> + .offset = vmstate_offset_pointer(_state, _field, _type), \
> +}
> +
> +#define VMSTATE_VARRAY_UINT32(_field, _state, _field_num, _version, _info, _type) {\
> + .name = (stringify(_field)), \
> + .version_id = (_version), \
> + .num_offset = vmstate_offset_value(_state, _field_num, uint32_t),\
> + .info =&(_info), \
> + .size = sizeof(_type), \
> + .flags = VMS_VARRAY_UINT32|VMS_POINTER, \
> + .offset = vmstate_offset_pointer(_state, _field, _type), \
> +}
> +
> +#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), \
> +}
> +
> +#define VMSTATE_STRUCT_TEST(_field, _state, _test, _version, _vmsd, _type) { \
> + .name = (stringify(_field)), \
> + .version_id = (_version), \
> + .field_exists = (_test), \
> + .vmsd =&(_vmsd), \
> + .size = sizeof(_type), \
> + .flags = VMS_STRUCT, \
> + .offset = vmstate_offset_value(_state, _field, _type), \
> +}
> +
> +#define VMSTATE_STRUCT_POINTER_TEST(_field, _state, _test, _vmsd, _type) { \
> + .name = (stringify(_field)), \
> + .field_exists = (_test), \
> + .vmsd =&(_vmsd), \
> + .size = sizeof(_type), \
> + .flags = VMS_STRUCT|VMS_POINTER, \
> + .offset = vmstate_offset_value(_state, _field, _type), \
> +}
> +
> +#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, \
> + .offset = vmstate_offset_array(_state, _field, _type, _num), \
> +}
> +
> +#define VMSTATE_STRUCT_ARRAY_TEST(_field, _state, _num, _test, _version, _vmsd, _type) { \
> + .name = (stringify(_field)), \
> + .num = (_num), \
> + .field_exists = (_test), \
> + .version_id = (_version), \
> + .vmsd =&(_vmsd), \
> + .size = sizeof(_type), \
> + .flags = VMS_STRUCT|VMS_ARRAY, \
> + .offset = vmstate_offset_array(_state, _field, _type, _num),\
> +}
> +
> +#define VMSTATE_STRUCT_VARRAY_UINT8(_field, _state, _field_num, _version, _vmsd, _type) { \
> + .name = (stringify(_field)), \
> + .num_offset = vmstate_offset_value(_state, _field_num, uint8_t), \
> + .version_id = (_version), \
> + .vmsd =&(_vmsd), \
> + .size = sizeof(_type), \
> + .flags = VMS_STRUCT|VMS_VARRAY_UINT8, \
> + .offset = offsetof(_state, _field), \
> +}
> +
> +#define VMSTATE_STRUCT_VARRAY_POINTER_INT32(_field, _state, _field_num, _vmsd, _type) { \
> + .name = (stringify(_field)), \
> + .version_id = 0, \
> + .num_offset = vmstate_offset_value(_state, _field_num, int32_t), \
> + .size = sizeof(_type), \
> + .vmsd =&(_vmsd), \
> + .flags = VMS_POINTER | VMS_VARRAY_INT32 | VMS_STRUCT, \
> + .offset = vmstate_offset_pointer(_state, _field, _type), \
> +}
> +
> +#define VMSTATE_STRUCT_VARRAY_POINTER_UINT16(_field, _state, _field_num, _vmsd, _type) { \
> + .name = (stringify(_field)), \
> + .version_id = 0, \
> + .num_offset = vmstate_offset_value(_state, _field_num, uint16_t),\
> + .size = sizeof(_type), \
> + .vmsd =&(_vmsd), \
> + .flags = VMS_POINTER | VMS_VARRAY_UINT16 | VMS_STRUCT, \
> + .offset = vmstate_offset_pointer(_state, _field, _type), \
> +}
> +
> +#define VMSTATE_STRUCT_VARRAY_INT32(_field, _state, _field_num, _version, _vmsd, _type) { \
> + .name = (stringify(_field)), \
> + .num_offset = vmstate_offset_value(_state, _field_num, int32_t), \
> + .version_id = (_version), \
> + .vmsd =&(_vmsd), \
> + .size = sizeof(_type), \
> + .flags = VMS_STRUCT|VMS_VARRAY_INT32, \
> + .offset = offsetof(_state, _field), \
> +}
> +
> +#define VMSTATE_STRUCT_VARRAY_UINT32(_field, _state, _field_num, _version, _vmsd, _type) { \
> + .name = (stringify(_field)), \
> + .num_offset = vmstate_offset_value(_state, _field_num, uint32_t), \
> + .version_id = (_version), \
> + .vmsd =&(_vmsd), \
> + .size = sizeof(_type), \
> + .flags = VMS_STRUCT|VMS_VARRAY_UINT32, \
> + .offset = offsetof(_state, _field), \
> +}
> +
> +#define VMSTATE_STATIC_BUFFER(_field, _state, _version, _test, _start, _size) { \
> + .name = (stringify(_field)), \
> + .version_id = (_version), \
> + .field_exists = (_test), \
> + .size = (_size - _start), \
> + .info =&vmstate_info_buffer, \
> + .flags = VMS_BUFFER, \
> + .offset = vmstate_offset_buffer(_state, _field) + _start, \
> +}
> +
> +#define VMSTATE_BUFFER_MULTIPLY(_field, _state, _version, _test, _start, _field_size, _multiply) { \
> + .name = (stringify(_field)), \
> + .version_id = (_version), \
> + .field_exists = (_test), \
> + .size_offset = vmstate_offset_value(_state, _field_size, uint32_t),\
> + .size = (_multiply), \
> + .info =&vmstate_info_buffer, \
> + .flags = VMS_VBUFFER|VMS_MULTIPLY, \
> + .offset = offsetof(_state, _field), \
> + .start = (_start), \
> +}
> +
> +#define VMSTATE_VBUFFER(_field, _state, _version, _test, _start, _field_size) { \
> + .name = (stringify(_field)), \
> + .version_id = (_version), \
> + .field_exists = (_test), \
> + .size_offset = vmstate_offset_value(_state, _field_size, int32_t),\
> + .info =&vmstate_info_buffer, \
> + .flags = VMS_VBUFFER|VMS_POINTER, \
> + .offset = offsetof(_state, _field), \
> + .start = (_start), \
> +}
> +
> +#define VMSTATE_VBUFFER_UINT32(_field, _state, _version, _test, _start, _field_size) { \
> + .name = (stringify(_field)), \
> + .version_id = (_version), \
> + .field_exists = (_test), \
> + .size_offset = vmstate_offset_value(_state, _field_size, uint32_t),\
> + .info =&vmstate_info_buffer, \
> + .flags = VMS_VBUFFER|VMS_POINTER, \
> + .offset = offsetof(_state, _field), \
> + .start = (_start), \
> +}
> +
> +#define VMSTATE_BUFFER_UNSAFE_INFO(_field, _state, _version, _info, _size) { \
> + .name = (stringify(_field)), \
> + .version_id = (_version), \
> + .size = (_size), \
> + .info =&(_info), \
> + .flags = VMS_BUFFER, \
> + .offset = offsetof(_state, _field), \
> +}
> +
> +#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, \
> +}
> +
> +/* _f : field name
> + _f_n : num of elements field_name
> + _n : num of elements
> + _s : struct state name
> + _v : version
> +*/
> +
> +#define VMSTATE_SINGLE(_field, _state, _version, _info, _type) \
> + VMSTATE_SINGLE_TEST(_field, _state, NULL, _version, _info, _type)
> +
> +#define VMSTATE_STRUCT(_field, _state, _version, _vmsd, _type) \
> + VMSTATE_STRUCT_TEST(_field, _state, NULL, _version, _vmsd, _type)
> +
> +#define VMSTATE_STRUCT_POINTER(_field, _state, _vmsd, _type) \
> + VMSTATE_STRUCT_POINTER_TEST(_field, _state, NULL, _vmsd, _type)
> +
> +#define VMSTATE_STRUCT_ARRAY(_field, _state, _num, _version, _vmsd, _type) \
> + VMSTATE_STRUCT_ARRAY_TEST(_field, _state, _num, NULL, _version, \
> + _vmsd, _type)
> +
> +#define VMSTATE_BOOL_V(_f, _s, _v) \
> + VMSTATE_SINGLE(_f, _s, _v, vmstate_info_bool, bool)
> +
> +#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_BOOL(_f, _s) \
> + VMSTATE_BOOL_V(_f, _s, 0)
> +
> +#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)
> +
> +#define VMSTATE_UINT8_EQUAL(_f, _s) \
> + VMSTATE_SINGLE(_f, _s, 0, vmstate_info_uint8_equal, uint8_t)
> +
> +#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)
> +
> +#define VMSTATE_INT32_EQUAL(_f, _s) \
> + VMSTATE_SINGLE(_f, _s, 0, vmstate_info_int32_equal, int32_t)
> +
> +#define VMSTATE_UINT32_EQUAL(_f, _s) \
> + VMSTATE_SINGLE(_f, _s, 0, vmstate_info_uint32_equal, uint32_t)
> +
> +#define VMSTATE_INT32_LE(_f, _s) \
> + VMSTATE_SINGLE(_f, _s, 0, vmstate_info_int32_le, int32_t)
> +
> +#define VMSTATE_UINT8_TEST(_f, _s, _t) \
> + VMSTATE_SINGLE_TEST(_f, _s, _t, 0, vmstate_info_uint8, uint8_t)
> +
> +#define VMSTATE_UINT16_TEST(_f, _s, _t) \
> + VMSTATE_SINGLE_TEST(_f, _s, _t, 0, vmstate_info_uint16, uint16_t)
> +
> +#define VMSTATE_UINT32_TEST(_f, _s, _t) \
> + VMSTATE_SINGLE_TEST(_f, _s, _t, 0, vmstate_info_uint32, uint32_t)
> +
> +#define VMSTATE_TIMER_TEST(_f, _s, _test) \
> + VMSTATE_POINTER_TEST(_f, _s, _test, vmstate_info_timer, QEMUTimer *)
> +
> +#define VMSTATE_TIMER(_f, _s) \
> + VMSTATE_TIMER_TEST(_f, _s, NULL)
> +
> +#define VMSTATE_TIMER_ARRAY(_f, _s, _n) \
> + VMSTATE_ARRAY_OF_POINTER(_f, _s, _n, 0, vmstate_info_timer, QEMUTimer *)
> +
> +#define VMSTATE_BOOL_ARRAY_V(_f, _s, _n, _v) \
> + VMSTATE_ARRAY(_f, _s, _n, _v, vmstate_info_bool, bool)
> +
> +#define VMSTATE_BOOL_ARRAY(_f, _s, _n) \
> + VMSTATE_BOOL_ARRAY_V(_f, _s, _n, 0)
> +
> +#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)
> +
> +#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)
> +
> +#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)
> +
> +#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)
> +
> +#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)
> +
> +#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)
> +
> +#define VMSTATE_UINT32_SUB_ARRAY(_f, _s, _start, _num) \
> + VMSTATE_SUB_ARRAY(_f, _s, _start, _num, 0, vmstate_info_uint32, uint32_t)
> +
> +#define VMSTATE_UINT32_ARRAY(_f, _s, _n) \
> + VMSTATE_UINT32_ARRAY_V(_f, _s, _n, 0)
> +
> +#define VMSTATE_INT64_ARRAY_V(_f, _s, _n, _v) \
> + VMSTATE_ARRAY(_f, _s, _n, _v, vmstate_info_int64, int64_t)
> +
> +#define VMSTATE_INT64_ARRAY(_f, _s, _n) \
> + VMSTATE_INT64_ARRAY_V(_f, _s, _n, 0)
> +
> +#define VMSTATE_BUFFER_V(_f, _s, _v) \
> + VMSTATE_STATIC_BUFFER(_f, _s, _v, NULL, 0, sizeof(typeof_field(_s, _f)))
> +
> +#define VMSTATE_BUFFER(_f, _s) \
> + 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)))
> +
> +#define VMSTATE_PARTIAL_VBUFFER(_f, _s, _size) \
> + VMSTATE_VBUFFER(_f, _s, 0, NULL, 0, _size)
> +
> +#define VMSTATE_PARTIAL_VBUFFER_UINT32(_f, _s, _size) \
> + VMSTATE_VBUFFER_UINT32(_f, _s, 0, NULL, 0, _size)
> +
> +#define VMSTATE_SUB_VBUFFER(_f, _s, _start, _size) \
> + VMSTATE_VBUFFER(_f, _s, 0, NULL, _start, _size)
> +
> +#define VMSTATE_BUFFER_TEST(_f, _s, _test) \
> + VMSTATE_STATIC_BUFFER(_f, _s, 0, _test, 0, sizeof(typeof_field(_s, _f)))
> +
> +#define VMSTATE_BUFFER_UNSAFE(_field, _state, _version, _size) \
> + VMSTATE_BUFFER_UNSAFE_INFO(_field, _state, _version, vmstate_info_buffer, _size)
> +
> +#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)
> +
> +#define VMSTATE_END_OF_LIST() \
> + {}
> +
> +int vmstate_load_state(QEMUFile *f, const VMStateDescription *vmsd,
> + void *opaque, int version_id);
> +void vmstate_save_state(QEMUFile *f, const VMStateDescription *vmsd,
> + void *opaque);
> +int vmstate_register(DeviceState *dev, int instance_id,
> + const VMStateDescription *vmsd, void *base);
> +int vmstate_register_with_alias_id(DeviceState *dev, int instance_id,
> + const VMStateDescription *vmsd,
> + void *base, int alias_id,
> + int required_for_version);
> +void vmstate_unregister(DeviceState *dev, const VMStateDescription *vmsd,
> + void *opaque);
> +
> +#endif
next prev parent reply other threads:[~2011-09-09 17:01 UTC|newest]
Thread overview: 5+ messages / expand[flat|nested] mbox.gz Atom feed top
2011-09-05 16:26 [Qemu-devel] [PATCH 1/2] ptimer: move declarations to ptimer.h Paolo Bonzini
2011-09-05 16:26 ` [Qemu-devel] [PATCH 2/2] vmstate: extract declarations out of hw/hw.h Paolo Bonzini
2011-09-09 17:00 ` Anthony Liguori [this message]
-- strict thread matches above, loose matches on Subject: below --
2011-12-06 17:34 [Qemu-devel] [PATCH 0/2] split hw/hw.h Paolo Bonzini
2011-12-06 17:34 ` [Qemu-devel] [PATCH 2/2] vmstate: extract declarations out of hw/hw.h Paolo Bonzini
2011-08-02 11:47 [Qemu-devel] [PATCH 0/2] split hw parts out of qemu-timer.h, and non-hw parts " Paolo Bonzini
2011-08-02 11:47 ` [Qemu-devel] [PATCH 2/2] vmstate: extract declarations " Paolo Bonzini
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=4E6A4636.4040102@codemonkey.ws \
--to=anthony@codemonkey.ws \
--cc=pbonzini@redhat.com \
--cc=qemu-devel@nongnu.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).