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