1 /* 2 * QEMU migration/snapshot declarations 3 * 4 * Copyright (c) 2009-2011 Red Hat, Inc. 5 * 6 * Original author: Juan Quintela <quintela (at) 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 #ifndef CONFIG_USER_ONLY 30 #include <migration/qemu-file.h> 31 #endif 32 33 typedef void SaveStateHandler(QEMUFile *f, void *opaque); 34 typedef int SaveLiveStateHandler(QEMUFile *f, int stage, void *opaque); 35 typedef int LoadStateHandler(QEMUFile *f, void *opaque, int version_id); 36 37 typedef struct SaveVMHandlers { 38 #if 0 39 /* This runs inside the iothread lock. */ 40 void (*set_params)(const MigrationParams *params, void * opaque); 41 #endif 42 SaveStateHandler *save_state; 43 SaveLiveStateHandler *save_live_state; 44 #if 0 45 void (*cancel)(void *opaque); 46 int (*save_live_complete)(QEMUFile *f, void *opaque); 47 48 /* This runs both outside and inside the iothread lock. */ 49 bool (*is_active)(void *opaque); 50 51 /* This runs outside the iothread lock in the migration case, and 52 * within the lock in the savevm case. The callback had better only 53 * use data that is local to the migration thread or protected 54 * by other locks. 55 */ 56 int (*save_live_iterate)(QEMUFile *f, void *opaque); 57 58 /* This runs outside the iothread lock! */ 59 int (*save_live_setup)(QEMUFile *f, void *opaque); 60 uint64_t (*save_live_pending)(QEMUFile *f, void *opaque, uint64_t max_size); 61 #endif 62 LoadStateHandler *load_state; 63 } SaveVMHandlers; 64 65 int register_savevm(DeviceState* dev, 66 const char *idstr, 67 int instance_id, 68 int version_id, 69 SaveStateHandler *save_state, 70 LoadStateHandler *load_state, 71 void *opaque); 72 73 int register_savevm_live(DeviceState* dev, 74 const char *idstr, 75 int instance_id, 76 int version_id, 77 SaveVMHandlers *ops, 78 void *opaque); 79 80 void unregister_savevm(DeviceState* dev, const char *idstr, void *opaque); 81 void register_device_unmigratable(DeviceState *dev, const char *idstr, 82 void *opaque); 83 84 typedef struct VMStateInfo VMStateInfo; 85 typedef struct VMStateDescription VMStateDescription; 86 87 struct VMStateInfo { 88 const char *name; 89 int (*get)(QEMUFile *f, void *pv, size_t size); 90 void (*put)(QEMUFile *f, void *pv, size_t size); 91 }; 92 93 enum VMStateFlags { 94 VMS_SINGLE = 0x001, 95 VMS_POINTER = 0x002, 96 VMS_ARRAY = 0x004, 97 VMS_STRUCT = 0x008, 98 VMS_VARRAY_INT32 = 0x010, /* Array with size in int32_t field*/ 99 VMS_BUFFER = 0x020, /* static sized buffer */ 100 VMS_ARRAY_OF_POINTER = 0x040, 101 VMS_VARRAY_UINT16 = 0x080, /* Array with size in uint16_t field */ 102 VMS_VBUFFER = 0x100, /* Buffer with size in int32_t field */ 103 VMS_MULTIPLY = 0x200, /* multiply "size" field by field_size */ 104 VMS_VARRAY_UINT8 = 0x400, /* Array with size in uint8_t field*/ 105 VMS_VARRAY_UINT32 = 0x800, /* Array with size in uint32_t field*/ 106 }; 107 108 typedef struct { 109 const char *name; 110 size_t offset; 111 size_t size; 112 size_t start; 113 int num; 114 size_t num_offset; 115 size_t size_offset; 116 const VMStateInfo *info; 117 enum VMStateFlags flags; 118 const VMStateDescription *vmsd; 119 int version_id; 120 bool (*field_exists)(void *opaque, int version_id); 121 } VMStateField; 122 123 typedef struct VMStateSubsection { 124 const VMStateDescription *vmsd; 125 bool (*needed)(void *opaque); 126 } VMStateSubsection; 127 128 struct VMStateDescription { 129 const char *name; 130 int unmigratable; 131 int version_id; 132 int minimum_version_id; 133 int minimum_version_id_old; 134 LoadStateHandler *load_state_old; 135 int (*pre_load)(void *opaque); 136 int (*post_load)(void *opaque, int version_id); 137 void (*pre_save)(void *opaque); 138 VMStateField *fields; 139 const VMStateSubsection *subsections; 140 }; 141 142 #ifdef CONFIG_USER_ONLY 143 extern const VMStateDescription vmstate_dummy; 144 #endif 145 146 extern const VMStateInfo vmstate_info_bool; 147 148 extern const VMStateInfo vmstate_info_int8; 149 extern const VMStateInfo vmstate_info_int16; 150 extern const VMStateInfo vmstate_info_int32; 151 extern const VMStateInfo vmstate_info_int64; 152 153 extern const VMStateInfo vmstate_info_uint8_equal; 154 extern const VMStateInfo vmstate_info_uint16_equal; 155 extern const VMStateInfo vmstate_info_int32_equal; 156 extern const VMStateInfo vmstate_info_uint32_equal; 157 extern const VMStateInfo vmstate_info_uint64_equal; 158 extern const VMStateInfo vmstate_info_int32_le; 159 160 extern const VMStateInfo vmstate_info_uint8; 161 extern const VMStateInfo vmstate_info_uint16; 162 extern const VMStateInfo vmstate_info_uint32; 163 extern const VMStateInfo vmstate_info_uint64; 164 165 extern const VMStateInfo vmstate_info_float64; 166 167 extern const VMStateInfo vmstate_info_timer; 168 extern const VMStateInfo vmstate_info_buffer; 169 extern const VMStateInfo vmstate_info_unused_buffer; 170 extern const VMStateInfo vmstate_info_bitmap; 171 172 #define type_check_2darray(t1,t2,n,m) ((t1(*)[n][m])0 - (t2*)0) 173 #define type_check_array(t1,t2,n) ((t1(*)[n])0 - (t2*)0) 174 #define type_check_pointer(t1,t2) ((t1**)0 - (t2*)0) 175 176 #define vmstate_offset_value(_state, _field, _type) \ 177 (offsetof(_state, _field) + \ 178 type_check(_type, typeof_field(_state, _field))) 179 180 #define vmstate_offset_pointer(_state, _field, _type) \ 181 (offsetof(_state, _field) + \ 182 type_check_pointer(_type, typeof_field(_state, _field))) 183 184 #define vmstate_offset_array(_state, _field, _type, _num) \ 185 (offsetof(_state, _field) + \ 186 type_check_array(_type, typeof_field(_state, _field), _num)) 187 188 #define vmstate_offset_2darray(_state, _field, _type, _n1, _n2) \ 189 (offsetof(_state, _field) + \ 190 type_check_2darray(_type, typeof_field(_state, _field), _n1, _n2)) 191 192 #define vmstate_offset_sub_array(_state, _field, _type, _start) \ 193 (offsetof(_state, _field[_start])) 194 195 #define vmstate_offset_buffer(_state, _field) \ 196 vmstate_offset_array(_state, _field, uint8_t, \ 197 sizeof(typeof_field(_state, _field))) 198 199 #define VMSTATE_SINGLE_TEST(_field, _state, _test, _version, _info, _type) { \ 200 .name = (stringify(_field)), \ 201 .version_id = (_version), \ 202 .field_exists = (_test), \ 203 .size = sizeof(_type), \ 204 .info = &(_info), \ 205 .flags = VMS_SINGLE, \ 206 .offset = vmstate_offset_value(_state, _field, _type), \ 207 } 208 209 #define VMSTATE_POINTER(_field, _state, _version, _info, _type) { \ 210 .name = (stringify(_field)), \ 211 .version_id = (_version), \ 212 .info = &(_info), \ 213 .size = sizeof(_type), \ 214 .flags = VMS_SINGLE|VMS_POINTER, \ 215 .offset = vmstate_offset_value(_state, _field, _type), \ 216 } 217 218 #define VMSTATE_POINTER_TEST(_field, _state, _test, _info, _type) { \ 219 .name = (stringify(_field)), \ 220 .info = &(_info), \ 221 .field_exists = (_test), \ 222 .size = sizeof(_type), \ 223 .flags = VMS_SINGLE|VMS_POINTER, \ 224 .offset = vmstate_offset_value(_state, _field, _type), \ 225 } 226 227 #define VMSTATE_ARRAY(_field, _state, _num, _version, _info, _type) {\ 228 .name = (stringify(_field)), \ 229 .version_id = (_version), \ 230 .num = (_num), \ 231 .info = &(_info), \ 232 .size = sizeof(_type), \ 233 .flags = VMS_ARRAY, \ 234 .offset = vmstate_offset_array(_state, _field, _type, _num), \ 235 } 236 237 #define VMSTATE_2DARRAY(_field, _state, _n1, _n2, _version, _info, _type) { \ 238 .name = (stringify(_field)), \ 239 .version_id = (_version), \ 240 .num = (_n1) * (_n2), \ 241 .info = &(_info), \ 242 .size = sizeof(_type), \ 243 .flags = VMS_ARRAY, \ 244 .offset = vmstate_offset_2darray(_state, _field, _type, _n1, _n2), \ 245 } 246 247 #define VMSTATE_ARRAY_TEST(_field, _state, _num, _test, _info, _type) {\ 248 .name = (stringify(_field)), \ 249 .field_exists = (_test), \ 250 .num = (_num), \ 251 .info = &(_info), \ 252 .size = sizeof(_type), \ 253 .flags = VMS_ARRAY, \ 254 .offset = vmstate_offset_array(_state, _field, _type, _num),\ 255 } 256 257 #define VMSTATE_SUB_ARRAY(_field, _state, _start, _num, _version, _info, _type) { \ 258 .name = (stringify(_field)), \ 259 .version_id = (_version), \ 260 .num = (_num), \ 261 .info = &(_info), \ 262 .size = sizeof(_type), \ 263 .flags = VMS_ARRAY, \ 264 .offset = vmstate_offset_sub_array(_state, _field, _type, _start), \ 265 } 266 267 #define VMSTATE_ARRAY_INT32_UNSAFE(_field, _state, _field_num, _info, _type) {\ 268 .name = (stringify(_field)), \ 269 .num_offset = vmstate_offset_value(_state, _field_num, int32_t), \ 270 .info = &(_info), \ 271 .size = sizeof(_type), \ 272 .flags = VMS_VARRAY_INT32, \ 273 .offset = offsetof(_state, _field), \ 274 } 275 276 #define VMSTATE_VARRAY_INT32(_field, _state, _field_num, _version, _info, _type) {\ 277 .name = (stringify(_field)), \ 278 .version_id = (_version), \ 279 .num_offset = vmstate_offset_value(_state, _field_num, int32_t), \ 280 .info = &(_info), \ 281 .size = sizeof(_type), \ 282 .flags = VMS_VARRAY_INT32|VMS_POINTER, \ 283 .offset = vmstate_offset_pointer(_state, _field, _type), \ 284 } 285 286 #define VMSTATE_VARRAY_UINT32(_field, _state, _field_num, _version, _info, _type) {\ 287 .name = (stringify(_field)), \ 288 .version_id = (_version), \ 289 .num_offset = vmstate_offset_value(_state, _field_num, uint32_t),\ 290 .info = &(_info), \ 291 .size = sizeof(_type), \ 292 .flags = VMS_VARRAY_UINT32|VMS_POINTER, \ 293 .offset = vmstate_offset_pointer(_state, _field, _type), \ 294 } 295 296 #define VMSTATE_VARRAY_UINT16_UNSAFE(_field, _state, _field_num, _version, _info, _type) {\ 297 .name = (stringify(_field)), \ 298 .version_id = (_version), \ 299 .num_offset = vmstate_offset_value(_state, _field_num, uint16_t),\ 300 .info = &(_info), \ 301 .size = sizeof(_type), \ 302 .flags = VMS_VARRAY_UINT16, \ 303 .offset = offsetof(_state, _field), \ 304 } 305 306 #define VMSTATE_STRUCT_TEST(_field, _state, _test, _version, _vmsd, _type) { \ 307 .name = (stringify(_field)), \ 308 .version_id = (_version), \ 309 .field_exists = (_test), \ 310 .vmsd = &(_vmsd), \ 311 .size = sizeof(_type), \ 312 .flags = VMS_STRUCT, \ 313 .offset = vmstate_offset_value(_state, _field, _type), \ 314 } 315 316 #define VMSTATE_STRUCT_POINTER_V(_field, _state, _version, _vmsd, _type) { \ 317 .name = (stringify(_field)), \ 318 .version_id = (_version), \ 319 .vmsd = &(_vmsd), \ 320 .size = sizeof(_type), \ 321 .flags = VMS_STRUCT|VMS_POINTER, \ 322 .offset = vmstate_offset_value(_state, _field, _type), \ 323 } 324 325 #define VMSTATE_STRUCT_POINTER_TEST_V(_field, _state, _test, _version, _vmsd, _type) { \ 326 .name = (stringify(_field)), \ 327 .version_id = (_version), \ 328 .field_exists = (_test), \ 329 .vmsd = &(_vmsd), \ 330 .size = sizeof(_type), \ 331 .flags = VMS_STRUCT|VMS_POINTER, \ 332 .offset = vmstate_offset_value(_state, _field, _type), \ 333 } 334 335 #define VMSTATE_ARRAY_OF_POINTER(_field, _state, _num, _version, _info, _type) {\ 336 .name = (stringify(_field)), \ 337 .version_id = (_version), \ 338 .num = (_num), \ 339 .info = &(_info), \ 340 .size = sizeof(_type), \ 341 .flags = VMS_ARRAY|VMS_ARRAY_OF_POINTER, \ 342 .offset = vmstate_offset_array(_state, _field, _type, _num), \ 343 } 344 345 #define VMSTATE_STRUCT_ARRAY_TEST(_field, _state, _num, _test, _version, _vmsd, _type) { \ 346 .name = (stringify(_field)), \ 347 .num = (_num), \ 348 .field_exists = (_test), \ 349 .version_id = (_version), \ 350 .vmsd = &(_vmsd), \ 351 .size = sizeof(_type), \ 352 .flags = VMS_STRUCT|VMS_ARRAY, \ 353 .offset = vmstate_offset_array(_state, _field, _type, _num),\ 354 } 355 356 #define VMSTATE_STRUCT_VARRAY_UINT8(_field, _state, _field_num, _version, _vmsd, _type) { \ 357 .name = (stringify(_field)), \ 358 .num_offset = vmstate_offset_value(_state, _field_num, uint8_t), \ 359 .version_id = (_version), \ 360 .vmsd = &(_vmsd), \ 361 .size = sizeof(_type), \ 362 .flags = VMS_STRUCT|VMS_VARRAY_UINT8, \ 363 .offset = offsetof(_state, _field), \ 364 } 365 366 #define VMSTATE_STRUCT_VARRAY_POINTER_INT32(_field, _state, _field_num, _vmsd, _type) { \ 367 .name = (stringify(_field)), \ 368 .version_id = 0, \ 369 .num_offset = vmstate_offset_value(_state, _field_num, int32_t), \ 370 .size = sizeof(_type), \ 371 .vmsd = &(_vmsd), \ 372 .flags = VMS_POINTER | VMS_VARRAY_INT32 | VMS_STRUCT, \ 373 .offset = vmstate_offset_pointer(_state, _field, _type), \ 374 } 375 376 #define VMSTATE_STRUCT_VARRAY_POINTER_UINT32(_field, _state, _field_num, _vmsd, _type) { \ 377 .name = (stringify(_field)), \ 378 .version_id = 0, \ 379 .num_offset = vmstate_offset_value(_state, _field_num, uint32_t),\ 380 .size = sizeof(_type), \ 381 .vmsd = &(_vmsd), \ 382 .flags = VMS_POINTER | VMS_VARRAY_INT32 | VMS_STRUCT, \ 383 .offset = vmstate_offset_pointer(_state, _field, _type), \ 384 } 385 386 #define VMSTATE_STRUCT_VARRAY_POINTER_UINT16(_field, _state, _field_num, _vmsd, _type) { \ 387 .name = (stringify(_field)), \ 388 .version_id = 0, \ 389 .num_offset = vmstate_offset_value(_state, _field_num, uint16_t),\ 390 .size = sizeof(_type), \ 391 .vmsd = &(_vmsd), \ 392 .flags = VMS_POINTER | VMS_VARRAY_UINT16 | VMS_STRUCT, \ 393 .offset = vmstate_offset_pointer(_state, _field, _type), \ 394 } 395 396 #define VMSTATE_STRUCT_VARRAY_INT32(_field, _state, _field_num, _version, _vmsd, _type) { \ 397 .name = (stringify(_field)), \ 398 .num_offset = vmstate_offset_value(_state, _field_num, int32_t), \ 399 .version_id = (_version), \ 400 .vmsd = &(_vmsd), \ 401 .size = sizeof(_type), \ 402 .flags = VMS_STRUCT|VMS_VARRAY_INT32, \ 403 .offset = offsetof(_state, _field), \ 404 } 405 406 #define VMSTATE_STRUCT_VARRAY_UINT32(_field, _state, _field_num, _version, _vmsd, _type) { \ 407 .name = (stringify(_field)), \ 408 .num_offset = vmstate_offset_value(_state, _field_num, uint32_t), \ 409 .version_id = (_version), \ 410 .vmsd = &(_vmsd), \ 411 .size = sizeof(_type), \ 412 .flags = VMS_STRUCT|VMS_VARRAY_UINT32, \ 413 .offset = offsetof(_state, _field), \ 414 } 415 416 #define VMSTATE_STATIC_BUFFER(_field, _state, _version, _test, _start, _size) { \ 417 .name = (stringify(_field)), \ 418 .version_id = (_version), \ 419 .field_exists = (_test), \ 420 .size = (_size - _start), \ 421 .info = &vmstate_info_buffer, \ 422 .flags = VMS_BUFFER, \ 423 .offset = vmstate_offset_buffer(_state, _field) + _start, \ 424 } 425 426 #define VMSTATE_VBUFFER_MULTIPLY(_field, _state, _version, _test, _start, _field_size, _multiply) { \ 427 .name = (stringify(_field)), \ 428 .version_id = (_version), \ 429 .field_exists = (_test), \ 430 .size_offset = vmstate_offset_value(_state, _field_size, uint32_t),\ 431 .size = (_multiply), \ 432 .info = &vmstate_info_buffer, \ 433 .flags = VMS_VBUFFER|VMS_POINTER|VMS_MULTIPLY, \ 434 .offset = offsetof(_state, _field), \ 435 .start = (_start), \ 436 } 437 438 #define VMSTATE_VBUFFER(_field, _state, _version, _test, _start, _field_size) { \ 439 .name = (stringify(_field)), \ 440 .version_id = (_version), \ 441 .field_exists = (_test), \ 442 .size_offset = vmstate_offset_value(_state, _field_size, int32_t),\ 443 .info = &vmstate_info_buffer, \ 444 .flags = VMS_VBUFFER|VMS_POINTER, \ 445 .offset = offsetof(_state, _field), \ 446 .start = (_start), \ 447 } 448 449 #define VMSTATE_VBUFFER_UINT32(_field, _state, _version, _test, _start, _field_size) { \ 450 .name = (stringify(_field)), \ 451 .version_id = (_version), \ 452 .field_exists = (_test), \ 453 .size_offset = vmstate_offset_value(_state, _field_size, uint32_t),\ 454 .info = &vmstate_info_buffer, \ 455 .flags = VMS_VBUFFER|VMS_POINTER, \ 456 .offset = offsetof(_state, _field), \ 457 .start = (_start), \ 458 } 459 460 #define VMSTATE_BUFFER_UNSAFE_INFO(_field, _state, _version, _info, _size) { \ 461 .name = (stringify(_field)), \ 462 .version_id = (_version), \ 463 .size = (_size), \ 464 .info = &(_info), \ 465 .flags = VMS_BUFFER, \ 466 .offset = offsetof(_state, _field), \ 467 } 468 469 #define VMSTATE_BUFFER_POINTER_UNSAFE(_field, _state, _version, _size) { \ 470 .name = (stringify(_field)), \ 471 .version_id = (_version), \ 472 .size = (_size), \ 473 .info = &vmstate_info_buffer, \ 474 .flags = VMS_BUFFER|VMS_POINTER, \ 475 .offset = offsetof(_state, _field), \ 476 } 477 478 #define VMSTATE_UNUSED_BUFFER(_test, _version, _size) { \ 479 .name = "unused", \ 480 .field_exists = (_test), \ 481 .version_id = (_version), \ 482 .size = (_size), \ 483 .info = &vmstate_info_unused_buffer, \ 484 .flags = VMS_BUFFER, \ 485 } 486 487 /* _field_size should be a int32_t field in the _state struct giving the 488 * size of the bitmap _field in bits. 489 */ 490 #define VMSTATE_BITMAP(_field, _state, _version, _field_size) { \ 491 .name = (stringify(_field)), \ 492 .version_id = (_version), \ 493 .size_offset = vmstate_offset_value(_state, _field_size, int32_t),\ 494 .info = &vmstate_info_bitmap, \ 495 .flags = VMS_VBUFFER|VMS_POINTER, \ 496 .offset = offsetof(_state, _field), \ 497 } 498 499 /* _f : field name 500 _f_n : num of elements field_name 501 _n : num of elements 502 _s : struct state name 503 _v : version 504 */ 505 506 #define VMSTATE_SINGLE(_field, _state, _version, _info, _type) \ 507 VMSTATE_SINGLE_TEST(_field, _state, NULL, _version, _info, _type) 508 509 #define VMSTATE_STRUCT(_field, _state, _version, _vmsd, _type) \ 510 VMSTATE_STRUCT_TEST(_field, _state, NULL, _version, _vmsd, _type) 511 512 #define VMSTATE_STRUCT_POINTER(_field, _state, _vmsd, _type) \ 513 VMSTATE_STRUCT_POINTER_V(_field, _state, 0, _vmsd, _type) 514 515 #define VMSTATE_STRUCT_POINTER_TEST(_field, _state, _test, _vmsd, _type) \ 516 VMSTATE_STRUCT_POINTER_TEST_V(_field, _state, _test, 0, _vmsd, _type) 517 518 #define VMSTATE_STRUCT_ARRAY(_field, _state, _num, _version, _vmsd, _type) \ 519 VMSTATE_STRUCT_ARRAY_TEST(_field, _state, _num, NULL, _version, \ 520 _vmsd, _type) 521 522 #define VMSTATE_BOOL_V(_f, _s, _v) \ 523 VMSTATE_SINGLE(_f, _s, _v, vmstate_info_bool, bool) 524 525 #define VMSTATE_INT8_V(_f, _s, _v) \ 526 VMSTATE_SINGLE(_f, _s, _v, vmstate_info_int8, int8_t) 527 #define VMSTATE_INT16_V(_f, _s, _v) \ 528 VMSTATE_SINGLE(_f, _s, _v, vmstate_info_int16, int16_t) 529 #define VMSTATE_INT32_V(_f, _s, _v) \ 530 VMSTATE_SINGLE(_f, _s, _v, vmstate_info_int32, int32_t) 531 #define VMSTATE_INT64_V(_f, _s, _v) \ 532 VMSTATE_SINGLE(_f, _s, _v, vmstate_info_int64, int64_t) 533 534 #define VMSTATE_UINT8_V(_f, _s, _v) \ 535 VMSTATE_SINGLE(_f, _s, _v, vmstate_info_uint8, uint8_t) 536 #define VMSTATE_UINT16_V(_f, _s, _v) \ 537 VMSTATE_SINGLE(_f, _s, _v, vmstate_info_uint16, uint16_t) 538 #define VMSTATE_UINT32_V(_f, _s, _v) \ 539 VMSTATE_SINGLE(_f, _s, _v, vmstate_info_uint32, uint32_t) 540 #define VMSTATE_UINT64_V(_f, _s, _v) \ 541 VMSTATE_SINGLE(_f, _s, _v, vmstate_info_uint64, uint64_t) 542 543 #define VMSTATE_BOOL(_f, _s) \ 544 VMSTATE_BOOL_V(_f, _s, 0) 545 546 #define VMSTATE_INT8(_f, _s) \ 547 VMSTATE_INT8_V(_f, _s, 0) 548 #define VMSTATE_INT16(_f, _s) \ 549 VMSTATE_INT16_V(_f, _s, 0) 550 #define VMSTATE_INT32(_f, _s) \ 551 VMSTATE_INT32_V(_f, _s, 0) 552 #define VMSTATE_INT64(_f, _s) \ 553 VMSTATE_INT64_V(_f, _s, 0) 554 555 #define VMSTATE_UINT8(_f, _s) \ 556 VMSTATE_UINT8_V(_f, _s, 0) 557 #define VMSTATE_UINT16(_f, _s) \ 558 VMSTATE_UINT16_V(_f, _s, 0) 559 #define VMSTATE_UINT32(_f, _s) \ 560 VMSTATE_UINT32_V(_f, _s, 0) 561 #define VMSTATE_UINT64(_f, _s) \ 562 VMSTATE_UINT64_V(_f, _s, 0) 563 564 #define VMSTATE_UINT8_EQUAL(_f, _s) \ 565 VMSTATE_SINGLE(_f, _s, 0, vmstate_info_uint8_equal, uint8_t) 566 567 #define VMSTATE_UINT16_EQUAL(_f, _s) \ 568 VMSTATE_SINGLE(_f, _s, 0, vmstate_info_uint16_equal, uint16_t) 569 570 #define VMSTATE_UINT16_EQUAL_V(_f, _s, _v) \ 571 VMSTATE_SINGLE(_f, _s, _v, vmstate_info_uint16_equal, uint16_t) 572 573 #define VMSTATE_INT32_EQUAL(_f, _s) \ 574 VMSTATE_SINGLE(_f, _s, 0, vmstate_info_int32_equal, int32_t) 575 576 #define VMSTATE_UINT32_EQUAL_V(_f, _s, _v) \ 577 VMSTATE_SINGLE(_f, _s, _v, vmstate_info_uint32_equal, uint32_t) 578 579 #define VMSTATE_UINT32_EQUAL(_f, _s) \ 580 VMSTATE_UINT32_EQUAL_V(_f, _s, 0) 581 582 #define VMSTATE_UINT64_EQUAL_V(_f, _s, _v) \ 583 VMSTATE_SINGLE(_f, _s, _v, vmstate_info_uint64_equal, uint64_t) 584 585 #define VMSTATE_UINT64_EQUAL(_f, _s) \ 586 VMSTATE_UINT64_EQUAL_V(_f, _s, 0) 587 588 #define VMSTATE_INT32_LE(_f, _s) \ 589 VMSTATE_SINGLE(_f, _s, 0, vmstate_info_int32_le, int32_t) 590 591 #define VMSTATE_UINT8_TEST(_f, _s, _t) \ 592 VMSTATE_SINGLE_TEST(_f, _s, _t, 0, vmstate_info_uint8, uint8_t) 593 594 #define VMSTATE_UINT16_TEST(_f, _s, _t) \ 595 VMSTATE_SINGLE_TEST(_f, _s, _t, 0, vmstate_info_uint16, uint16_t) 596 597 #define VMSTATE_UINT32_TEST(_f, _s, _t) \ 598 VMSTATE_SINGLE_TEST(_f, _s, _t, 0, vmstate_info_uint32, uint32_t) 599 600 601 #define VMSTATE_FLOAT64_V(_f, _s, _v) \ 602 VMSTATE_SINGLE(_f, _s, _v, vmstate_info_float64, float64) 603 604 #define VMSTATE_FLOAT64(_f, _s) \ 605 VMSTATE_FLOAT64_V(_f, _s, 0) 606 607 #define VMSTATE_TIMER_TEST(_f, _s, _test) \ 608 VMSTATE_POINTER_TEST(_f, _s, _test, vmstate_info_timer, QEMUTimer *) 609 610 #define VMSTATE_TIMER_V(_f, _s, _v) \ 611 VMSTATE_POINTER(_f, _s, _v, vmstate_info_timer, QEMUTimer *) 612 613 #define VMSTATE_TIMER(_f, _s) \ 614 VMSTATE_TIMER_V(_f, _s, 0) 615 616 #define VMSTATE_TIMER_ARRAY(_f, _s, _n) \ 617 VMSTATE_ARRAY_OF_POINTER(_f, _s, _n, 0, vmstate_info_timer, QEMUTimer *) 618 619 #define VMSTATE_BOOL_ARRAY_V(_f, _s, _n, _v) \ 620 VMSTATE_ARRAY(_f, _s, _n, _v, vmstate_info_bool, bool) 621 622 #define VMSTATE_BOOL_ARRAY(_f, _s, _n) \ 623 VMSTATE_BOOL_ARRAY_V(_f, _s, _n, 0) 624 625 #define VMSTATE_UINT16_ARRAY_V(_f, _s, _n, _v) \ 626 VMSTATE_ARRAY(_f, _s, _n, _v, vmstate_info_uint16, uint16_t) 627 628 #define VMSTATE_UINT16_2DARRAY_V(_f, _s, _n1, _n2, _v) \ 629 VMSTATE_2DARRAY(_f, _s, _n1, _n2, _v, vmstate_info_uint16, uint16_t) 630 631 #define VMSTATE_UINT16_ARRAY(_f, _s, _n) \ 632 VMSTATE_UINT16_ARRAY_V(_f, _s, _n, 0) 633 634 #define VMSTATE_UINT16_2DARRAY(_f, _s, _n1, _n2) \ 635 VMSTATE_UINT16_2DARRAY_V(_f, _s, _n1, _n2, 0) 636 637 #define VMSTATE_UINT8_2DARRAY_V(_f, _s, _n1, _n2, _v) \ 638 VMSTATE_2DARRAY(_f, _s, _n1, _n2, _v, vmstate_info_uint8, uint8_t) 639 640 #define VMSTATE_UINT8_ARRAY_V(_f, _s, _n, _v) \ 641 VMSTATE_ARRAY(_f, _s, _n, _v, vmstate_info_uint8, uint8_t) 642 643 #define VMSTATE_UINT8_ARRAY(_f, _s, _n) \ 644 VMSTATE_UINT8_ARRAY_V(_f, _s, _n, 0) 645 646 #define VMSTATE_UINT8_2DARRAY(_f, _s, _n1, _n2) \ 647 VMSTATE_UINT8_2DARRAY_V(_f, _s, _n1, _n2, 0) 648 649 #define VMSTATE_UINT32_ARRAY_V(_f, _s, _n, _v) \ 650 VMSTATE_ARRAY(_f, _s, _n, _v, vmstate_info_uint32, uint32_t) 651 652 #define VMSTATE_UINT32_ARRAY(_f, _s, _n) \ 653 VMSTATE_UINT32_ARRAY_V(_f, _s, _n, 0) 654 655 #define VMSTATE_UINT64_ARRAY_V(_f, _s, _n, _v) \ 656 VMSTATE_ARRAY(_f, _s, _n, _v, vmstate_info_uint64, uint64_t) 657 658 #define VMSTATE_UINT64_ARRAY(_f, _s, _n) \ 659 VMSTATE_UINT64_ARRAY_V(_f, _s, _n, 0) 660 661 #define VMSTATE_INT16_ARRAY_V(_f, _s, _n, _v) \ 662 VMSTATE_ARRAY(_f, _s, _n, _v, vmstate_info_int16, int16_t) 663 664 #define VMSTATE_INT16_ARRAY(_f, _s, _n) \ 665 VMSTATE_INT16_ARRAY_V(_f, _s, _n, 0) 666 667 #define VMSTATE_INT32_ARRAY_V(_f, _s, _n, _v) \ 668 VMSTATE_ARRAY(_f, _s, _n, _v, vmstate_info_int32, int32_t) 669 670 #define VMSTATE_INT32_ARRAY(_f, _s, _n) \ 671 VMSTATE_INT32_ARRAY_V(_f, _s, _n, 0) 672 673 #define VMSTATE_UINT32_SUB_ARRAY(_f, _s, _start, _num) \ 674 VMSTATE_SUB_ARRAY(_f, _s, _start, _num, 0, vmstate_info_uint32, uint32_t) 675 676 #define VMSTATE_UINT32_ARRAY(_f, _s, _n) \ 677 VMSTATE_UINT32_ARRAY_V(_f, _s, _n, 0) 678 679 #define VMSTATE_INT64_ARRAY_V(_f, _s, _n, _v) \ 680 VMSTATE_ARRAY(_f, _s, _n, _v, vmstate_info_int64, int64_t) 681 682 #define VMSTATE_INT64_ARRAY(_f, _s, _n) \ 683 VMSTATE_INT64_ARRAY_V(_f, _s, _n, 0) 684 685 #define VMSTATE_FLOAT64_ARRAY_V(_f, _s, _n, _v) \ 686 VMSTATE_ARRAY(_f, _s, _n, _v, vmstate_info_float64, float64) 687 688 #define VMSTATE_FLOAT64_ARRAY(_f, _s, _n) \ 689 VMSTATE_FLOAT64_ARRAY_V(_f, _s, _n, 0) 690 691 #define VMSTATE_BUFFER_V(_f, _s, _v) \ 692 VMSTATE_STATIC_BUFFER(_f, _s, _v, NULL, 0, sizeof(typeof_field(_s, _f))) 693 694 #define VMSTATE_BUFFER(_f, _s) \ 695 VMSTATE_BUFFER_V(_f, _s, 0) 696 697 #define VMSTATE_PARTIAL_BUFFER(_f, _s, _size) \ 698 VMSTATE_STATIC_BUFFER(_f, _s, 0, NULL, 0, _size) 699 700 #define VMSTATE_BUFFER_START_MIDDLE(_f, _s, _start) \ 701 VMSTATE_STATIC_BUFFER(_f, _s, 0, NULL, _start, sizeof(typeof_field(_s, _f))) 702 703 #define VMSTATE_PARTIAL_VBUFFER(_f, _s, _size) \ 704 VMSTATE_VBUFFER(_f, _s, 0, NULL, 0, _size) 705 706 #define VMSTATE_PARTIAL_VBUFFER_UINT32(_f, _s, _size) \ 707 VMSTATE_VBUFFER_UINT32(_f, _s, 0, NULL, 0, _size) 708 709 #define VMSTATE_SUB_VBUFFER(_f, _s, _start, _size) \ 710 VMSTATE_VBUFFER(_f, _s, 0, NULL, _start, _size) 711 712 #define VMSTATE_BUFFER_TEST(_f, _s, _test) \ 713 VMSTATE_STATIC_BUFFER(_f, _s, 0, _test, 0, sizeof(typeof_field(_s, _f))) 714 715 #define VMSTATE_BUFFER_UNSAFE(_field, _state, _version, _size) \ 716 VMSTATE_BUFFER_UNSAFE_INFO(_field, _state, _version, vmstate_info_buffer, _size) 717 718 #define VMSTATE_UNUSED_V(_v, _size) \ 719 VMSTATE_UNUSED_BUFFER(NULL, _v, _size) 720 721 #define VMSTATE_UNUSED(_size) \ 722 VMSTATE_UNUSED_V(0, _size) 723 724 #define VMSTATE_UNUSED_TEST(_test, _size) \ 725 VMSTATE_UNUSED_BUFFER(_test, 0, _size) 726 727 #define VMSTATE_END_OF_LIST() \ 728 {} 729 730 int vmstate_load_state(QEMUFile *f, const VMStateDescription *vmsd, 731 void *opaque, int version_id); 732 void vmstate_save_state(QEMUFile *f, const VMStateDescription *vmsd, 733 void *opaque); 734 735 int vmstate_register_with_alias_id(DeviceState *dev, int instance_id, 736 const VMStateDescription *vmsd, 737 void *base, int alias_id, 738 int required_for_version); 739 740 static inline int vmstate_register(DeviceState *dev, int instance_id, 741 const VMStateDescription *vmsd, 742 void *opaque) 743 { 744 return vmstate_register_with_alias_id(dev, instance_id, vmsd, 745 opaque, -1, 0); 746 } 747 748 void vmstate_unregister(DeviceState *dev, const VMStateDescription *vmsd, 749 void *opaque); 750 751 #ifndef CONFIG_ANDROID 752 struct MemoryRegion; 753 void vmstate_register_ram(struct MemoryRegion *memory, DeviceState *dev); 754 void vmstate_unregister_ram(struct MemoryRegion *memory, DeviceState *dev); 755 void vmstate_register_ram_global(struct MemoryRegion *memory); 756 #endif // !CONFIG_ANDROID 757 758 #endif 759
