File:  [Qemu by Fabrice Bellard] / qemu / vmstate.h
Revision 1.1.1.1 (vendor branch): download - view: text, annotated - select for diffs
Tue Apr 24 19:34:04 2018 UTC (23 months, 2 weeks ago) by root
Branches: qemu, MAIN
CVS tags: qemu1101, HEAD
qemu 1.1.1

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

unix.superglobalmegacorp.com