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_array(t1,t2,n) ((t1(*)[n])0 - (t2*)0) 168 #define type_check_pointer(t1,t2) ((t1**)0 - (t2*)0) 169 170 #define vmstate_offset_value(_state, _field, _type) \ 171 (offsetof(_state, _field) + \ 172 type_check(_type, typeof_field(_state, _field))) 173 174 #define vmstate_offset_pointer(_state, _field, _type) \ 175 (offsetof(_state, _field) + \ 176 type_check_pointer(_type, typeof_field(_state, _field))) 177 178 #define vmstate_offset_array(_state, _field, _type, _num) \ 179 (offsetof(_state, _field) + \ 180 type_check_array(_type, typeof_field(_state, _field), _num)) 181 182 #define vmstate_offset_sub_array(_state, _field, _type, _start) \ 183 (offsetof(_state, _field[_start])) 184 185 #define vmstate_offset_buffer(_state, _field) \ 186 vmstate_offset_array(_state, _field, uint8_t, \ 187 sizeof(typeof_field(_state, _field))) 188 189 #define VMSTATE_SINGLE_TEST(_field, _state, _test, _version, _info, _type) { \ 190 .name = (stringify(_field)), \ 191 .version_id = (_version), \ 192 .field_exists = (_test), \ 193 .size = sizeof(_type), \ 194 .info = &(_info), \ 195 .flags = VMS_SINGLE, \ 196 .offset = vmstate_offset_value(_state, _field, _type), \ 197 } 198 199 #define VMSTATE_POINTER(_field, _state, _version, _info, _type) { \ 200 .name = (stringify(_field)), \ 201 .version_id = (_version), \ 202 .info = &(_info), \ 203 .size = sizeof(_type), \ 204 .flags = VMS_SINGLE|VMS_POINTER, \ 205 .offset = vmstate_offset_value(_state, _field, _type), \ 206 } 207 208 #define VMSTATE_POINTER_TEST(_field, _state, _test, _info, _type) { \ 209 .name = (stringify(_field)), \ 210 .info = &(_info), \ 211 .field_exists = (_test), \ 212 .size = sizeof(_type), \ 213 .flags = VMS_SINGLE|VMS_POINTER, \ 214 .offset = vmstate_offset_value(_state, _field, _type), \ 215 } 216 217 #define VMSTATE_ARRAY(_field, _state, _num, _version, _info, _type) {\ 218 .name = (stringify(_field)), \ 219 .version_id = (_version), \ 220 .num = (_num), \ 221 .info = &(_info), \ 222 .size = sizeof(_type), \ 223 .flags = VMS_ARRAY, \ 224 .offset = vmstate_offset_array(_state, _field, _type, _num), \ 225 } 226 227 #define VMSTATE_ARRAY_TEST(_field, _state, _num, _test, _info, _type) {\ 228 .name = (stringify(_field)), \ 229 .field_exists = (_test), \ 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_SUB_ARRAY(_field, _state, _start, _num, _version, _info, _type) { \ 238 .name = (stringify(_field)), \ 239 .version_id = (_version), \ 240 .num = (_num), \ 241 .info = &(_info), \ 242 .size = sizeof(_type), \ 243 .flags = VMS_ARRAY, \ 244 .offset = vmstate_offset_sub_array(_state, _field, _type, _start), \ 245 } 246 247 #define VMSTATE_ARRAY_INT32_UNSAFE(_field, _state, _field_num, _info, _type) {\ 248 .name = (stringify(_field)), \ 249 .num_offset = vmstate_offset_value(_state, _field_num, int32_t), \ 250 .info = &(_info), \ 251 .size = sizeof(_type), \ 252 .flags = VMS_VARRAY_INT32, \ 253 .offset = offsetof(_state, _field), \ 254 } 255 256 #define VMSTATE_VARRAY_INT32(_field, _state, _field_num, _version, _info, _type) {\ 257 .name = (stringify(_field)), \ 258 .version_id = (_version), \ 259 .num_offset = vmstate_offset_value(_state, _field_num, int32_t), \ 260 .info = &(_info), \ 261 .size = sizeof(_type), \ 262 .flags = VMS_VARRAY_INT32|VMS_POINTER, \ 263 .offset = vmstate_offset_pointer(_state, _field, _type), \ 264 } 265 266 #define VMSTATE_VARRAY_UINT32(_field, _state, _field_num, _version, _info, _type) {\ 267 .name = (stringify(_field)), \ 268 .version_id = (_version), \ 269 .num_offset = vmstate_offset_value(_state, _field_num, uint32_t),\ 270 .info = &(_info), \ 271 .size = sizeof(_type), \ 272 .flags = VMS_VARRAY_UINT32|VMS_POINTER, \ 273 .offset = vmstate_offset_pointer(_state, _field, _type), \ 274 } 275 276 #define VMSTATE_VARRAY_UINT16_UNSAFE(_field, _state, _field_num, _version, _info, _type) {\ 277 .name = (stringify(_field)), \ 278 .version_id = (_version), \ 279 .num_offset = vmstate_offset_value(_state, _field_num, uint16_t),\ 280 .info = &(_info), \ 281 .size = sizeof(_type), \ 282 .flags = VMS_VARRAY_UINT16, \ 283 .offset = offsetof(_state, _field), \ 284 } 285 286 #define VMSTATE_STRUCT_TEST(_field, _state, _test, _version, _vmsd, _type) { \ 287 .name = (stringify(_field)), \ 288 .version_id = (_version), \ 289 .field_exists = (_test), \ 290 .vmsd = &(_vmsd), \ 291 .size = sizeof(_type), \ 292 .flags = VMS_STRUCT, \ 293 .offset = vmstate_offset_value(_state, _field, _type), \ 294 } 295 296 #define VMSTATE_STRUCT_POINTER_TEST(_field, _state, _test, _vmsd, _type) { \ 297 .name = (stringify(_field)), \ 298 .field_exists = (_test), \ 299 .vmsd = &(_vmsd), \ 300 .size = sizeof(_type), \ 301 .flags = VMS_STRUCT|VMS_POINTER, \ 302 .offset = vmstate_offset_value(_state, _field, _type), \ 303 } 304 305 #define VMSTATE_ARRAY_OF_POINTER(_field, _state, _num, _version, _info, _type) {\ 306 .name = (stringify(_field)), \ 307 .version_id = (_version), \ 308 .num = (_num), \ 309 .info = &(_info), \ 310 .size = sizeof(_type), \ 311 .flags = VMS_ARRAY|VMS_ARRAY_OF_POINTER, \ 312 .offset = vmstate_offset_array(_state, _field, _type, _num), \ 313 } 314 315 #define VMSTATE_STRUCT_ARRAY_TEST(_field, _state, _num, _test, _version, _vmsd, _type) { \ 316 .name = (stringify(_field)), \ 317 .num = (_num), \ 318 .field_exists = (_test), \ 319 .version_id = (_version), \ 320 .vmsd = &(_vmsd), \ 321 .size = sizeof(_type), \ 322 .flags = VMS_STRUCT|VMS_ARRAY, \ 323 .offset = vmstate_offset_array(_state, _field, _type, _num),\ 324 } 325 326 #define VMSTATE_STRUCT_VARRAY_UINT8(_field, _state, _field_num, _version, _vmsd, _type) { \ 327 .name = (stringify(_field)), \ 328 .num_offset = vmstate_offset_value(_state, _field_num, uint8_t), \ 329 .version_id = (_version), \ 330 .vmsd = &(_vmsd), \ 331 .size = sizeof(_type), \ 332 .flags = VMS_STRUCT|VMS_VARRAY_UINT8, \ 333 .offset = offsetof(_state, _field), \ 334 } 335 336 #define VMSTATE_STRUCT_VARRAY_POINTER_INT32(_field, _state, _field_num, _vmsd, _type) { \ 337 .name = (stringify(_field)), \ 338 .version_id = 0, \ 339 .num_offset = vmstate_offset_value(_state, _field_num, int32_t), \ 340 .size = sizeof(_type), \ 341 .vmsd = &(_vmsd), \ 342 .flags = VMS_POINTER | VMS_VARRAY_INT32 | VMS_STRUCT, \ 343 .offset = vmstate_offset_pointer(_state, _field, _type), \ 344 } 345 346 #define VMSTATE_STRUCT_VARRAY_POINTER_UINT32(_field, _state, _field_num, _vmsd, _type) { \ 347 .name = (stringify(_field)), \ 348 .version_id = 0, \ 349 .num_offset = vmstate_offset_value(_state, _field_num, uint32_t),\ 350 .size = sizeof(_type), \ 351 .vmsd = &(_vmsd), \ 352 .flags = VMS_POINTER | VMS_VARRAY_INT32 | VMS_STRUCT, \ 353 .offset = vmstate_offset_pointer(_state, _field, _type), \ 354 } 355 356 #define VMSTATE_STRUCT_VARRAY_POINTER_UINT16(_field, _state, _field_num, _vmsd, _type) { \ 357 .name = (stringify(_field)), \ 358 .version_id = 0, \ 359 .num_offset = vmstate_offset_value(_state, _field_num, uint16_t),\ 360 .size = sizeof(_type), \ 361 .vmsd = &(_vmsd), \ 362 .flags = VMS_POINTER | VMS_VARRAY_UINT16 | VMS_STRUCT, \ 363 .offset = vmstate_offset_pointer(_state, _field, _type), \ 364 } 365 366 #define VMSTATE_STRUCT_VARRAY_INT32(_field, _state, _field_num, _version, _vmsd, _type) { \ 367 .name = (stringify(_field)), \ 368 .num_offset = vmstate_offset_value(_state, _field_num, int32_t), \ 369 .version_id = (_version), \ 370 .vmsd = &(_vmsd), \ 371 .size = sizeof(_type), \ 372 .flags = VMS_STRUCT|VMS_VARRAY_INT32, \ 373 .offset = offsetof(_state, _field), \ 374 } 375 376 #define VMSTATE_STRUCT_VARRAY_UINT32(_field, _state, _field_num, _version, _vmsd, _type) { \ 377 .name = (stringify(_field)), \ 378 .num_offset = vmstate_offset_value(_state, _field_num, uint32_t), \ 379 .version_id = (_version), \ 380 .vmsd = &(_vmsd), \ 381 .size = sizeof(_type), \ 382 .flags = VMS_STRUCT|VMS_VARRAY_UINT32, \ 383 .offset = offsetof(_state, _field), \ 384 } 385 386 #define VMSTATE_STATIC_BUFFER(_field, _state, _version, _test, _start, _size) { \ 387 .name = (stringify(_field)), \ 388 .version_id = (_version), \ 389 .field_exists = (_test), \ 390 .size = (_size - _start), \ 391 .info = &vmstate_info_buffer, \ 392 .flags = VMS_BUFFER, \ 393 .offset = vmstate_offset_buffer(_state, _field) + _start, \ 394 } 395 396 #define VMSTATE_VBUFFER_MULTIPLY(_field, _state, _version, _test, _start, _field_size, _multiply) { \ 397 .name = (stringify(_field)), \ 398 .version_id = (_version), \ 399 .field_exists = (_test), \ 400 .size_offset = vmstate_offset_value(_state, _field_size, uint32_t),\ 401 .size = (_multiply), \ 402 .info = &vmstate_info_buffer, \ 403 .flags = VMS_VBUFFER|VMS_POINTER|VMS_MULTIPLY, \ 404 .offset = offsetof(_state, _field), \ 405 .start = (_start), \ 406 } 407 408 #define VMSTATE_VBUFFER(_field, _state, _version, _test, _start, _field_size) { \ 409 .name = (stringify(_field)), \ 410 .version_id = (_version), \ 411 .field_exists = (_test), \ 412 .size_offset = vmstate_offset_value(_state, _field_size, int32_t),\ 413 .info = &vmstate_info_buffer, \ 414 .flags = VMS_VBUFFER|VMS_POINTER, \ 415 .offset = offsetof(_state, _field), \ 416 .start = (_start), \ 417 } 418 419 #define VMSTATE_VBUFFER_UINT32(_field, _state, _version, _test, _start, _field_size) { \ 420 .name = (stringify(_field)), \ 421 .version_id = (_version), \ 422 .field_exists = (_test), \ 423 .size_offset = vmstate_offset_value(_state, _field_size, uint32_t),\ 424 .info = &vmstate_info_buffer, \ 425 .flags = VMS_VBUFFER|VMS_POINTER, \ 426 .offset = offsetof(_state, _field), \ 427 .start = (_start), \ 428 } 429 430 #define VMSTATE_BUFFER_UNSAFE_INFO(_field, _state, _version, _info, _size) { \ 431 .name = (stringify(_field)), \ 432 .version_id = (_version), \ 433 .size = (_size), \ 434 .info = &(_info), \ 435 .flags = VMS_BUFFER, \ 436 .offset = offsetof(_state, _field), \ 437 } 438 439 #define VMSTATE_UNUSED_BUFFER(_test, _version, _size) { \ 440 .name = "unused", \ 441 .field_exists = (_test), \ 442 .version_id = (_version), \ 443 .size = (_size), \ 444 .info = &vmstate_info_unused_buffer, \ 445 .flags = VMS_BUFFER, \ 446 } 447 448 /* _field_size should be a int32_t field in the _state struct giving the 449 * size of the bitmap _field in bits. 450 */ 451 #define VMSTATE_BITMAP(_field, _state, _version, _field_size) { \ 452 .name = (stringify(_field)), \ 453 .version_id = (_version), \ 454 .size_offset = vmstate_offset_value(_state, _field_size, int32_t),\ 455 .info = &vmstate_info_bitmap, \ 456 .flags = VMS_VBUFFER|VMS_POINTER, \ 457 .offset = offsetof(_state, _field), \ 458 } 459 460 /* _f : field name 461 _f_n : num of elements field_name 462 _n : num of elements 463 _s : struct state name 464 _v : version 465 */ 466 467 #define VMSTATE_SINGLE(_field, _state, _version, _info, _type) \ 468 VMSTATE_SINGLE_TEST(_field, _state, NULL, _version, _info, _type) 469 470 #define VMSTATE_STRUCT(_field, _state, _version, _vmsd, _type) \ 471 VMSTATE_STRUCT_TEST(_field, _state, NULL, _version, _vmsd, _type) 472 473 #define VMSTATE_STRUCT_POINTER(_field, _state, _vmsd, _type) \ 474 VMSTATE_STRUCT_POINTER_TEST(_field, _state, NULL, _vmsd, _type) 475 476 #define VMSTATE_STRUCT_ARRAY(_field, _state, _num, _version, _vmsd, _type) \ 477 VMSTATE_STRUCT_ARRAY_TEST(_field, _state, _num, NULL, _version, \ 478 _vmsd, _type) 479 480 #define VMSTATE_BOOL_V(_f, _s, _v) \ 481 VMSTATE_SINGLE(_f, _s, _v, vmstate_info_bool, bool) 482 483 #define VMSTATE_INT8_V(_f, _s, _v) \ 484 VMSTATE_SINGLE(_f, _s, _v, vmstate_info_int8, int8_t) 485 #define VMSTATE_INT16_V(_f, _s, _v) \ 486 VMSTATE_SINGLE(_f, _s, _v, vmstate_info_int16, int16_t) 487 #define VMSTATE_INT32_V(_f, _s, _v) \ 488 VMSTATE_SINGLE(_f, _s, _v, vmstate_info_int32, int32_t) 489 #define VMSTATE_INT64_V(_f, _s, _v) \ 490 VMSTATE_SINGLE(_f, _s, _v, vmstate_info_int64, int64_t) 491 492 #define VMSTATE_UINT8_V(_f, _s, _v) \ 493 VMSTATE_SINGLE(_f, _s, _v, vmstate_info_uint8, uint8_t) 494 #define VMSTATE_UINT16_V(_f, _s, _v) \ 495 VMSTATE_SINGLE(_f, _s, _v, vmstate_info_uint16, uint16_t) 496 #define VMSTATE_UINT32_V(_f, _s, _v) \ 497 VMSTATE_SINGLE(_f, _s, _v, vmstate_info_uint32, uint32_t) 498 #define VMSTATE_UINT64_V(_f, _s, _v) \ 499 VMSTATE_SINGLE(_f, _s, _v, vmstate_info_uint64, uint64_t) 500 501 #define VMSTATE_BOOL(_f, _s) \ 502 VMSTATE_BOOL_V(_f, _s, 0) 503 504 #define VMSTATE_INT8(_f, _s) \ 505 VMSTATE_INT8_V(_f, _s, 0) 506 #define VMSTATE_INT16(_f, _s) \ 507 VMSTATE_INT16_V(_f, _s, 0) 508 #define VMSTATE_INT32(_f, _s) \ 509 VMSTATE_INT32_V(_f, _s, 0) 510 #define VMSTATE_INT64(_f, _s) \ 511 VMSTATE_INT64_V(_f, _s, 0) 512 513 #define VMSTATE_UINT8(_f, _s) \ 514 VMSTATE_UINT8_V(_f, _s, 0) 515 #define VMSTATE_UINT16(_f, _s) \ 516 VMSTATE_UINT16_V(_f, _s, 0) 517 #define VMSTATE_UINT32(_f, _s) \ 518 VMSTATE_UINT32_V(_f, _s, 0) 519 #define VMSTATE_UINT64(_f, _s) \ 520 VMSTATE_UINT64_V(_f, _s, 0) 521 522 #define VMSTATE_UINT8_EQUAL(_f, _s) \ 523 VMSTATE_SINGLE(_f, _s, 0, vmstate_info_uint8_equal, uint8_t) 524 525 #define VMSTATE_UINT16_EQUAL(_f, _s) \ 526 VMSTATE_SINGLE(_f, _s, 0, vmstate_info_uint16_equal, uint16_t) 527 528 #define VMSTATE_UINT16_EQUAL_V(_f, _s, _v) \ 529 VMSTATE_SINGLE(_f, _s, _v, vmstate_info_uint16_equal, uint16_t) 530 531 #define VMSTATE_INT32_EQUAL(_f, _s) \ 532 VMSTATE_SINGLE(_f, _s, 0, vmstate_info_int32_equal, int32_t) 533 534 #define VMSTATE_UINT32_EQUAL_V(_f, _s, _v) \ 535 VMSTATE_SINGLE(_f, _s, _v, vmstate_info_uint32_equal, uint32_t) 536 537 #define VMSTATE_UINT32_EQUAL(_f, _s) \ 538 VMSTATE_UINT32_EQUAL_V(_f, _s, 0) 539 540 #define VMSTATE_UINT64_EQUAL_V(_f, _s, _v) \ 541 VMSTATE_SINGLE(_f, _s, _v, vmstate_info_uint64_equal, uint64_t) 542 543 #define VMSTATE_UINT64_EQUAL(_f, _s) \ 544 VMSTATE_UINT64_EQUAL_V(_f, _s, 0) 545 546 #define VMSTATE_INT32_LE(_f, _s) \ 547 VMSTATE_SINGLE(_f, _s, 0, vmstate_info_int32_le, int32_t) 548 549 #define VMSTATE_UINT8_TEST(_f, _s, _t) \ 550 VMSTATE_SINGLE_TEST(_f, _s, _t, 0, vmstate_info_uint8, uint8_t) 551 552 #define VMSTATE_UINT16_TEST(_f, _s, _t) \ 553 VMSTATE_SINGLE_TEST(_f, _s, _t, 0, vmstate_info_uint16, uint16_t) 554 555 #define VMSTATE_UINT32_TEST(_f, _s, _t) \ 556 VMSTATE_SINGLE_TEST(_f, _s, _t, 0, vmstate_info_uint32, uint32_t) 557 558 559 #define VMSTATE_FLOAT64_V(_f, _s, _v) \ 560 VMSTATE_SINGLE(_f, _s, _v, vmstate_info_float64, float64) 561 562 #define VMSTATE_FLOAT64(_f, _s) \ 563 VMSTATE_FLOAT64_V(_f, _s, 0) 564 565 #define VMSTATE_TIMER_TEST(_f, _s, _test) \ 566 VMSTATE_POINTER_TEST(_f, _s, _test, vmstate_info_timer, QEMUTimer *) 567 568 #define VMSTATE_TIMER_V(_f, _s, _v) \ 569 VMSTATE_POINTER(_f, _s, _v, vmstate_info_timer, QEMUTimer *) 570 571 #define VMSTATE_TIMER(_f, _s) \ 572 VMSTATE_TIMER_V(_f, _s, 0) 573 574 #define VMSTATE_TIMER_ARRAY(_f, _s, _n) \ 575 VMSTATE_ARRAY_OF_POINTER(_f, _s, _n, 0, vmstate_info_timer, QEMUTimer *) 576 577 #define VMSTATE_BOOL_ARRAY_V(_f, _s, _n, _v) \ 578 VMSTATE_ARRAY(_f, _s, _n, _v, vmstate_info_bool, bool) 579 580 #define VMSTATE_BOOL_ARRAY(_f, _s, _n) \ 581 VMSTATE_BOOL_ARRAY_V(_f, _s, _n, 0) 582 583 #define VMSTATE_UINT16_ARRAY_V(_f, _s, _n, _v) \ 584 VMSTATE_ARRAY(_f, _s, _n, _v, vmstate_info_uint16, uint16_t) 585 586 #define VMSTATE_UINT16_ARRAY(_f, _s, _n) \ 587 VMSTATE_UINT16_ARRAY_V(_f, _s, _n, 0) 588 589 #define VMSTATE_UINT8_ARRAY_V(_f, _s, _n, _v) \ 590 VMSTATE_ARRAY(_f, _s, _n, _v, vmstate_info_uint8, uint8_t) 591 592 #define VMSTATE_UINT8_ARRAY(_f, _s, _n) \ 593 VMSTATE_UINT8_ARRAY_V(_f, _s, _n, 0) 594 595 #define VMSTATE_UINT32_ARRAY_V(_f, _s, _n, _v) \ 596 VMSTATE_ARRAY(_f, _s, _n, _v, vmstate_info_uint32, uint32_t) 597 598 #define VMSTATE_UINT32_ARRAY(_f, _s, _n) \ 599 VMSTATE_UINT32_ARRAY_V(_f, _s, _n, 0) 600 601 #define VMSTATE_UINT64_ARRAY_V(_f, _s, _n, _v) \ 602 VMSTATE_ARRAY(_f, _s, _n, _v, vmstate_info_uint64, uint64_t) 603 604 #define VMSTATE_UINT64_ARRAY(_f, _s, _n) \ 605 VMSTATE_UINT64_ARRAY_V(_f, _s, _n, 0) 606 607 #define VMSTATE_INT16_ARRAY_V(_f, _s, _n, _v) \ 608 VMSTATE_ARRAY(_f, _s, _n, _v, vmstate_info_int16, int16_t) 609 610 #define VMSTATE_INT16_ARRAY(_f, _s, _n) \ 611 VMSTATE_INT16_ARRAY_V(_f, _s, _n, 0) 612 613 #define VMSTATE_INT32_ARRAY_V(_f, _s, _n, _v) \ 614 VMSTATE_ARRAY(_f, _s, _n, _v, vmstate_info_int32, int32_t) 615 616 #define VMSTATE_INT32_ARRAY(_f, _s, _n) \ 617 VMSTATE_INT32_ARRAY_V(_f, _s, _n, 0) 618 619 #define VMSTATE_UINT32_SUB_ARRAY(_f, _s, _start, _num) \ 620 VMSTATE_SUB_ARRAY(_f, _s, _start, _num, 0, vmstate_info_uint32, uint32_t) 621 622 #define VMSTATE_UINT32_ARRAY(_f, _s, _n) \ 623 VMSTATE_UINT32_ARRAY_V(_f, _s, _n, 0) 624 625 #define VMSTATE_INT64_ARRAY_V(_f, _s, _n, _v) \ 626 VMSTATE_ARRAY(_f, _s, _n, _v, vmstate_info_int64, int64_t) 627 628 #define VMSTATE_INT64_ARRAY(_f, _s, _n) \ 629 VMSTATE_INT64_ARRAY_V(_f, _s, _n, 0) 630 631 #define VMSTATE_FLOAT64_ARRAY_V(_f, _s, _n, _v) \ 632 VMSTATE_ARRAY(_f, _s, _n, _v, vmstate_info_float64, float64) 633 634 #define VMSTATE_FLOAT64_ARRAY(_f, _s, _n) \ 635 VMSTATE_FLOAT64_ARRAY_V(_f, _s, _n, 0) 636 637 #define VMSTATE_BUFFER_V(_f, _s, _v) \ 638 VMSTATE_STATIC_BUFFER(_f, _s, _v, NULL, 0, sizeof(typeof_field(_s, _f))) 639 640 #define VMSTATE_BUFFER(_f, _s) \ 641 VMSTATE_BUFFER_V(_f, _s, 0) 642 643 #define VMSTATE_PARTIAL_BUFFER(_f, _s, _size) \ 644 VMSTATE_STATIC_BUFFER(_f, _s, 0, NULL, 0, _size) 645 646 #define VMSTATE_BUFFER_START_MIDDLE(_f, _s, _start) \ 647 VMSTATE_STATIC_BUFFER(_f, _s, 0, NULL, _start, sizeof(typeof_field(_s, _f))) 648 649 #define VMSTATE_PARTIAL_VBUFFER(_f, _s, _size) \ 650 VMSTATE_VBUFFER(_f, _s, 0, NULL, 0, _size) 651 652 #define VMSTATE_PARTIAL_VBUFFER_UINT32(_f, _s, _size) \ 653 VMSTATE_VBUFFER_UINT32(_f, _s, 0, NULL, 0, _size) 654 655 #define VMSTATE_SUB_VBUFFER(_f, _s, _start, _size) \ 656 VMSTATE_VBUFFER(_f, _s, 0, NULL, _start, _size) 657 658 #define VMSTATE_BUFFER_TEST(_f, _s, _test) \ 659 VMSTATE_STATIC_BUFFER(_f, _s, 0, _test, 0, sizeof(typeof_field(_s, _f))) 660 661 #define VMSTATE_BUFFER_UNSAFE(_field, _state, _version, _size) \ 662 VMSTATE_BUFFER_UNSAFE_INFO(_field, _state, _version, vmstate_info_buffer, _size) 663 664 #define VMSTATE_UNUSED_V(_v, _size) \ 665 VMSTATE_UNUSED_BUFFER(NULL, _v, _size) 666 667 #define VMSTATE_UNUSED(_size) \ 668 VMSTATE_UNUSED_V(0, _size) 669 670 #define VMSTATE_UNUSED_TEST(_test, _size) \ 671 VMSTATE_UNUSED_BUFFER(_test, 0, _size) 672 673 #define VMSTATE_END_OF_LIST() \ 674 {} 675 676 int vmstate_load_state(QEMUFile *f, const VMStateDescription *vmsd, 677 void *opaque, int version_id); 678 void vmstate_save_state(QEMUFile *f, const VMStateDescription *vmsd, 679 void *opaque); 680 681 int vmstate_register_with_alias_id(DeviceState *dev, int instance_id, 682 const VMStateDescription *vmsd, 683 void *base, int alias_id, 684 int required_for_version); 685 686 static inline int vmstate_register(DeviceState *dev, int instance_id, 687 const VMStateDescription *vmsd, 688 void *opaque) 689 { 690 return vmstate_register_with_alias_id(dev, instance_id, vmsd, 691 opaque, -1, 0); 692 } 693 694 void vmstate_unregister(DeviceState *dev, const VMStateDescription *vmsd, 695 void *opaque); 696 697 struct MemoryRegion; 698 void vmstate_register_ram(struct MemoryRegion *memory, DeviceState *dev); 699 void vmstate_unregister_ram(struct MemoryRegion *memory, DeviceState *dev); 700 void vmstate_register_ram_global(struct MemoryRegion *memory); 701 702 #endif 703