1 /* Declarations for use by hardware emulation. */ 2 #ifndef QEMU_HW_H 3 #define QEMU_HW_H 4 5 #include "qemu-common.h" 6 7 #if defined(TARGET_PHYS_ADDR_BITS) && !defined(NEED_CPU_H) 8 #include "cpu-common.h" 9 #endif 10 11 #include "ioport.h" 12 #include "irq.h" 13 14 /* VM Load/Save */ 15 16 /* This function writes a chunk of data to a file at the given position. 17 * The pos argument can be ignored if the file is only being used for 18 * streaming. The handler should try to write all of the data it can. 19 */ 20 typedef int (QEMUFilePutBufferFunc)(void *opaque, const uint8_t *buf, 21 int64_t pos, int size); 22 23 /* Read a chunk of data from a file at the given position. The pos argument 24 * can be ignored if the file is only be used for streaming. The number of 25 * bytes actually read should be returned. 26 */ 27 typedef int (QEMUFileGetBufferFunc)(void *opaque, uint8_t *buf, 28 int64_t pos, int size); 29 30 /* Close a file and return an error code */ 31 typedef int (QEMUFileCloseFunc)(void *opaque); 32 33 /* Called to determine if the file has exceeded it's bandwidth allocation. The 34 * bandwidth capping is a soft limit, not a hard limit. 35 */ 36 typedef int (QEMUFileRateLimit)(void *opaque); 37 38 /* Called to change the current bandwidth allocation. This function must return 39 * the new actual bandwidth. It should be new_rate if everything goes ok, and 40 * the old rate otherwise 41 */ 42 typedef int64_t (QEMUFileSetRateLimit)(void *opaque, int64_t new_rate); 43 typedef int64_t (QEMUFileGetRateLimit)(void *opaque); 44 45 QEMUFile *qemu_fopen_ops(void *opaque, QEMUFilePutBufferFunc *put_buffer, 46 QEMUFileGetBufferFunc *get_buffer, 47 QEMUFileCloseFunc *close, 48 QEMUFileRateLimit *rate_limit, 49 QEMUFileSetRateLimit *set_rate_limit, 50 QEMUFileGetRateLimit *get_rate_limit); 51 QEMUFile *qemu_fopen(const char *filename, const char *mode); 52 QEMUFile *qemu_fdopen(int fd, const char *mode); 53 QEMUFile *qemu_fopen_socket(int fd); 54 QEMUFile *qemu_popen(FILE *popen_file, const char *mode); 55 QEMUFile *qemu_popen_cmd(const char *command, const char *mode); 56 int qemu_stdio_fd(QEMUFile *f); 57 void qemu_fflush(QEMUFile *f); 58 int qemu_fclose(QEMUFile *f); 59 void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size); 60 void qemu_put_byte(QEMUFile *f, int v); 61 62 static inline void qemu_put_ubyte(QEMUFile *f, unsigned int v) 63 { 64 qemu_put_byte(f, (int)v); 65 } 66 67 #define qemu_put_sbyte qemu_put_byte 68 69 void qemu_put_be16(QEMUFile *f, unsigned int v); 70 void qemu_put_be32(QEMUFile *f, unsigned int v); 71 void qemu_put_be64(QEMUFile *f, uint64_t v); 72 int qemu_get_buffer(QEMUFile *f, uint8_t *buf, int size); 73 int qemu_get_byte(QEMUFile *f); 74 75 static inline unsigned int qemu_get_ubyte(QEMUFile *f) 76 { 77 return (unsigned int)qemu_get_byte(f); 78 } 79 80 #define qemu_get_sbyte qemu_get_byte 81 82 unsigned int qemu_get_be16(QEMUFile *f); 83 unsigned int qemu_get_be32(QEMUFile *f); 84 uint64_t qemu_get_be64(QEMUFile *f); 85 int qemu_file_rate_limit(QEMUFile *f); 86 int64_t qemu_file_set_rate_limit(QEMUFile *f, int64_t new_rate); 87 int64_t qemu_file_get_rate_limit(QEMUFile *f); 88 int qemu_file_has_error(QEMUFile *f); 89 void qemu_file_set_error(QEMUFile *f); 90 91 /* Try to send any outstanding data. This function is useful when output is 92 * halted due to rate limiting or EAGAIN errors occur as it can be used to 93 * resume output. */ 94 void qemu_file_put_notify(QEMUFile *f); 95 96 static inline void qemu_put_be64s(QEMUFile *f, const uint64_t *pv) 97 { 98 qemu_put_be64(f, *pv); 99 } 100 101 static inline void qemu_put_be32s(QEMUFile *f, const uint32_t *pv) 102 { 103 qemu_put_be32(f, *pv); 104 } 105 106 static inline void qemu_put_be16s(QEMUFile *f, const uint16_t *pv) 107 { 108 qemu_put_be16(f, *pv); 109 } 110 111 static inline void qemu_put_8s(QEMUFile *f, const uint8_t *pv) 112 { 113 qemu_put_byte(f, *pv); 114 } 115 116 static inline void qemu_get_be64s(QEMUFile *f, uint64_t *pv) 117 { 118 *pv = qemu_get_be64(f); 119 } 120 121 static inline void qemu_get_be32s(QEMUFile *f, uint32_t *pv) 122 { 123 *pv = qemu_get_be32(f); 124 } 125 126 static inline void qemu_get_be16s(QEMUFile *f, uint16_t *pv) 127 { 128 *pv = qemu_get_be16(f); 129 } 130 131 static inline void qemu_get_8s(QEMUFile *f, uint8_t *pv) 132 { 133 *pv = qemu_get_byte(f); 134 } 135 136 // Signed versions for type safety 137 static inline void qemu_put_sbuffer(QEMUFile *f, const int8_t *buf, int size) 138 { 139 qemu_put_buffer(f, (const uint8_t *)buf, size); 140 } 141 142 static inline void qemu_put_sbe16(QEMUFile *f, int v) 143 { 144 qemu_put_be16(f, (unsigned int)v); 145 } 146 147 static inline void qemu_put_sbe32(QEMUFile *f, int v) 148 { 149 qemu_put_be32(f, (unsigned int)v); 150 } 151 152 static inline void qemu_put_sbe64(QEMUFile *f, int64_t v) 153 { 154 qemu_put_be64(f, (uint64_t)v); 155 } 156 157 static inline size_t qemu_get_sbuffer(QEMUFile *f, int8_t *buf, int size) 158 { 159 return qemu_get_buffer(f, (uint8_t *)buf, size); 160 } 161 162 static inline int qemu_get_sbe16(QEMUFile *f) 163 { 164 return (int)qemu_get_be16(f); 165 } 166 167 static inline int qemu_get_sbe32(QEMUFile *f) 168 { 169 return (int)qemu_get_be32(f); 170 } 171 172 static inline int64_t qemu_get_sbe64(QEMUFile *f) 173 { 174 return (int64_t)qemu_get_be64(f); 175 } 176 177 static inline void qemu_put_s8s(QEMUFile *f, const int8_t *pv) 178 { 179 qemu_put_8s(f, (const uint8_t *)pv); 180 } 181 182 static inline void qemu_put_sbe16s(QEMUFile *f, const int16_t *pv) 183 { 184 qemu_put_be16s(f, (const uint16_t *)pv); 185 } 186 187 static inline void qemu_put_sbe32s(QEMUFile *f, const int32_t *pv) 188 { 189 qemu_put_be32s(f, (const uint32_t *)pv); 190 } 191 192 static inline void qemu_put_sbe64s(QEMUFile *f, const int64_t *pv) 193 { 194 qemu_put_be64s(f, (const uint64_t *)pv); 195 } 196 197 static inline void qemu_get_s8s(QEMUFile *f, int8_t *pv) 198 { 199 qemu_get_8s(f, (uint8_t *)pv); 200 } 201 202 static inline void qemu_get_sbe16s(QEMUFile *f, int16_t *pv) 203 { 204 qemu_get_be16s(f, (uint16_t *)pv); 205 } 206 207 static inline void qemu_get_sbe32s(QEMUFile *f, int32_t *pv) 208 { 209 qemu_get_be32s(f, (uint32_t *)pv); 210 } 211 212 static inline void qemu_get_sbe64s(QEMUFile *f, int64_t *pv) 213 { 214 qemu_get_be64s(f, (uint64_t *)pv); 215 } 216 217 #ifdef NEED_CPU_H 218 #if TARGET_LONG_BITS == 64 219 #define qemu_put_betl qemu_put_be64 220 #define qemu_get_betl qemu_get_be64 221 #define qemu_put_betls qemu_put_be64s 222 #define qemu_get_betls qemu_get_be64s 223 #define qemu_put_sbetl qemu_put_sbe64 224 #define qemu_get_sbetl qemu_get_sbe64 225 #define qemu_put_sbetls qemu_put_sbe64s 226 #define qemu_get_sbetls qemu_get_sbe64s 227 #else 228 #define qemu_put_betl qemu_put_be32 229 #define qemu_get_betl qemu_get_be32 230 #define qemu_put_betls qemu_put_be32s 231 #define qemu_get_betls qemu_get_be32s 232 #define qemu_put_sbetl qemu_put_sbe32 233 #define qemu_get_sbetl qemu_get_sbe32 234 #define qemu_put_sbetls qemu_put_sbe32s 235 #define qemu_get_sbetls qemu_get_sbe32s 236 #endif 237 #endif 238 239 int64_t qemu_ftell(QEMUFile *f); 240 int64_t qemu_fseek(QEMUFile *f, int64_t pos, int whence); 241 242 typedef void SaveSetParamsHandler(int blk_enable, int shared, void * opaque); 243 typedef void SaveStateHandler(QEMUFile *f, void *opaque); 244 typedef int SaveLiveStateHandler(Monitor *mon, QEMUFile *f, int stage, 245 void *opaque); 246 typedef int LoadStateHandler(QEMUFile *f, void *opaque, int version_id); 247 248 int register_savevm(DeviceState *dev, 249 const char *idstr, 250 int instance_id, 251 int version_id, 252 SaveStateHandler *save_state, 253 LoadStateHandler *load_state, 254 void *opaque); 255 256 int register_savevm_live(DeviceState *dev, 257 const char *idstr, 258 int instance_id, 259 int version_id, 260 SaveSetParamsHandler *set_params, 261 SaveLiveStateHandler *save_live_state, 262 SaveStateHandler *save_state, 263 LoadStateHandler *load_state, 264 void *opaque); 265 266 void unregister_savevm(DeviceState *dev, const char *idstr, void *opaque); 267 void register_device_unmigratable(DeviceState *dev, const char *idstr, 268 void *opaque); 269 270 typedef void QEMUResetHandler(void *opaque); 271 272 void qemu_register_reset(QEMUResetHandler *func, void *opaque); 273 void qemu_unregister_reset(QEMUResetHandler *func, void *opaque); 274 275 /* handler to set the boot_device order for a specific type of QEMUMachine */ 276 /* return 0 if success */ 277 typedef int QEMUBootSetHandler(void *opaque, const char *boot_devices); 278 void qemu_register_boot_set(QEMUBootSetHandler *func, void *opaque); 279 int qemu_boot_set(const char *boot_devices); 280 281 typedef struct VMStateInfo VMStateInfo; 282 typedef struct VMStateDescription VMStateDescription; 283 284 struct VMStateInfo { 285 const char *name; 286 int (*get)(QEMUFile *f, void *pv, size_t size); 287 void (*put)(QEMUFile *f, void *pv, size_t size); 288 }; 289 290 enum VMStateFlags { 291 VMS_SINGLE = 0x001, 292 VMS_POINTER = 0x002, 293 VMS_ARRAY = 0x004, 294 VMS_STRUCT = 0x008, 295 VMS_VARRAY_INT32 = 0x010, /* Array with size in int32_t field*/ 296 VMS_BUFFER = 0x020, /* static sized buffer */ 297 VMS_ARRAY_OF_POINTER = 0x040, 298 VMS_VARRAY_UINT16 = 0x080, /* Array with size in uint16_t field */ 299 VMS_VBUFFER = 0x100, /* Buffer with size in int32_t field */ 300 VMS_MULTIPLY = 0x200, /* multiply "size" field by field_size */ 301 }; 302 303 typedef struct { 304 const char *name; 305 size_t offset; 306 size_t size; 307 size_t start; 308 int num; 309 size_t num_offset; 310 size_t size_offset; 311 const VMStateInfo *info; 312 enum VMStateFlags flags; 313 const VMStateDescription *vmsd; 314 int version_id; 315 bool (*field_exists)(void *opaque, int version_id); 316 } VMStateField; 317 318 typedef struct VMStateSubsection { 319 const VMStateDescription *vmsd; 320 bool (*needed)(void *opaque); 321 } VMStateSubsection; 322 323 struct VMStateDescription { 324 const char *name; 325 int version_id; 326 int minimum_version_id; 327 int minimum_version_id_old; 328 LoadStateHandler *load_state_old; 329 int (*pre_load)(void *opaque); 330 int (*post_load)(void *opaque, int version_id); 331 void (*pre_save)(void *opaque); 332 VMStateField *fields; 333 const VMStateSubsection *subsections; 334 }; 335 336 extern const VMStateInfo vmstate_info_bool; 337 338 extern const VMStateInfo vmstate_info_int8; 339 extern const VMStateInfo vmstate_info_int16; 340 extern const VMStateInfo vmstate_info_int32; 341 extern const VMStateInfo vmstate_info_int64; 342 343 extern const VMStateInfo vmstate_info_uint8_equal; 344 extern const VMStateInfo vmstate_info_uint16_equal; 345 extern const VMStateInfo vmstate_info_int32_equal; 346 extern const VMStateInfo vmstate_info_uint32_equal; 347 extern const VMStateInfo vmstate_info_int32_le; 348 349 extern const VMStateInfo vmstate_info_uint8; 350 extern const VMStateInfo vmstate_info_uint16; 351 extern const VMStateInfo vmstate_info_uint32; 352 extern const VMStateInfo vmstate_info_uint64; 353 354 extern const VMStateInfo vmstate_info_timer; 355 extern const VMStateInfo vmstate_info_ptimer; 356 extern const VMStateInfo vmstate_info_buffer; 357 extern const VMStateInfo vmstate_info_unused_buffer; 358 359 #define type_check_array(t1,t2,n) ((t1(*)[n])0 - (t2*)0) 360 #define type_check_pointer(t1,t2) ((t1**)0 - (t2*)0) 361 362 #define vmstate_offset_value(_state, _field, _type) \ 363 (offsetof(_state, _field) + \ 364 type_check(_type, typeof_field(_state, _field))) 365 366 #define vmstate_offset_pointer(_state, _field, _type) \ 367 (offsetof(_state, _field) + \ 368 type_check_pointer(_type, typeof_field(_state, _field))) 369 370 #define vmstate_offset_array(_state, _field, _type, _num) \ 371 (offsetof(_state, _field) + \ 372 type_check_array(_type, typeof_field(_state, _field), _num)) 373 374 #define vmstate_offset_sub_array(_state, _field, _type, _start) \ 375 (offsetof(_state, _field[_start])) 376 377 #define vmstate_offset_buffer(_state, _field) \ 378 vmstate_offset_array(_state, _field, uint8_t, \ 379 sizeof(typeof_field(_state, _field))) 380 381 #define VMSTATE_SINGLE_TEST(_field, _state, _test, _version, _info, _type) { \ 382 .name = (stringify(_field)), \ 383 .version_id = (_version), \ 384 .field_exists = (_test), \ 385 .size = sizeof(_type), \ 386 .info = &(_info), \ 387 .flags = VMS_SINGLE, \ 388 .offset = vmstate_offset_value(_state, _field, _type), \ 389 } 390 391 #define VMSTATE_POINTER(_field, _state, _version, _info, _type) { \ 392 .name = (stringify(_field)), \ 393 .version_id = (_version), \ 394 .info = &(_info), \ 395 .size = sizeof(_type), \ 396 .flags = VMS_SINGLE|VMS_POINTER, \ 397 .offset = vmstate_offset_value(_state, _field, _type), \ 398 } 399 400 #define VMSTATE_ARRAY(_field, _state, _num, _version, _info, _type) {\ 401 .name = (stringify(_field)), \ 402 .version_id = (_version), \ 403 .num = (_num), \ 404 .info = &(_info), \ 405 .size = sizeof(_type), \ 406 .flags = VMS_ARRAY, \ 407 .offset = vmstate_offset_array(_state, _field, _type, _num), \ 408 } 409 410 #define VMSTATE_ARRAY_TEST(_field, _state, _num, _test, _info, _type) {\ 411 .name = (stringify(_field)), \ 412 .field_exists = (_test), \ 413 .num = (_num), \ 414 .info = &(_info), \ 415 .size = sizeof(_type), \ 416 .flags = VMS_ARRAY, \ 417 .offset = vmstate_offset_array(_state, _field, _type, _num),\ 418 } 419 420 #define VMSTATE_SUB_ARRAY(_field, _state, _start, _num, _version, _info, _type) { \ 421 .name = (stringify(_field)), \ 422 .version_id = (_version), \ 423 .num = (_num), \ 424 .info = &(_info), \ 425 .size = sizeof(_type), \ 426 .flags = VMS_ARRAY, \ 427 .offset = vmstate_offset_sub_array(_state, _field, _type, _start), \ 428 } 429 430 #define VMSTATE_VARRAY_INT32(_field, _state, _field_num, _version, _info, _type) {\ 431 .name = (stringify(_field)), \ 432 .version_id = (_version), \ 433 .num_offset = vmstate_offset_value(_state, _field_num, int32_t), \ 434 .info = &(_info), \ 435 .size = sizeof(_type), \ 436 .flags = VMS_VARRAY_INT32|VMS_POINTER, \ 437 .offset = vmstate_offset_pointer(_state, _field, _type), \ 438 } 439 440 #define VMSTATE_VARRAY_UINT16_UNSAFE(_field, _state, _field_num, _version, _info, _type) {\ 441 .name = (stringify(_field)), \ 442 .version_id = (_version), \ 443 .num_offset = vmstate_offset_value(_state, _field_num, uint16_t),\ 444 .info = &(_info), \ 445 .size = sizeof(_type), \ 446 .flags = VMS_VARRAY_UINT16, \ 447 .offset = offsetof(_state, _field), \ 448 } 449 450 #define VMSTATE_STRUCT_TEST(_field, _state, _test, _version, _vmsd, _type) { \ 451 .name = (stringify(_field)), \ 452 .version_id = (_version), \ 453 .field_exists = (_test), \ 454 .vmsd = &(_vmsd), \ 455 .size = sizeof(_type), \ 456 .flags = VMS_STRUCT, \ 457 .offset = vmstate_offset_value(_state, _field, _type), \ 458 } 459 460 #define VMSTATE_STRUCT_POINTER_TEST(_field, _state, _test, _vmsd, _type) { \ 461 .name = (stringify(_field)), \ 462 .field_exists = (_test), \ 463 .vmsd = &(_vmsd), \ 464 .size = sizeof(_type), \ 465 .flags = VMS_STRUCT|VMS_POINTER, \ 466 .offset = vmstate_offset_value(_state, _field, _type), \ 467 } 468 469 #define VMSTATE_ARRAY_OF_POINTER(_field, _state, _num, _version, _info, _type) {\ 470 .name = (stringify(_field)), \ 471 .version_id = (_version), \ 472 .num = (_num), \ 473 .info = &(_info), \ 474 .size = sizeof(_type), \ 475 .flags = VMS_ARRAY|VMS_ARRAY_OF_POINTER, \ 476 .offset = vmstate_offset_array(_state, _field, _type, _num), \ 477 } 478 479 #define VMSTATE_STRUCT_ARRAY_TEST(_field, _state, _num, _test, _version, _vmsd, _type) { \ 480 .name = (stringify(_field)), \ 481 .num = (_num), \ 482 .field_exists = (_test), \ 483 .version_id = (_version), \ 484 .vmsd = &(_vmsd), \ 485 .size = sizeof(_type), \ 486 .flags = VMS_STRUCT|VMS_ARRAY, \ 487 .offset = vmstate_offset_array(_state, _field, _type, _num),\ 488 } 489 490 #define VMSTATE_STRUCT_VARRAY_UINT8(_field, _state, _field_num, _version, _vmsd, _type) { \ 491 .name = (stringify(_field)), \ 492 .num_offset = vmstate_offset_value(_state, _field_num, uint8_t), \ 493 .version_id = (_version), \ 494 .vmsd = &(_vmsd), \ 495 .size = sizeof(_type), \ 496 .flags = VMS_STRUCT|VMS_VARRAY_INT32, \ 497 .offset = offsetof(_state, _field), \ 498 } 499 500 #define VMSTATE_STRUCT_VARRAY_POINTER_INT32(_field, _state, _field_num, _vmsd, _type) { \ 501 .name = (stringify(_field)), \ 502 .version_id = 0, \ 503 .num_offset = vmstate_offset_value(_state, _field_num, int32_t), \ 504 .size = sizeof(_type), \ 505 .vmsd = &(_vmsd), \ 506 .flags = VMS_POINTER | VMS_VARRAY_INT32 | VMS_STRUCT, \ 507 .offset = vmstate_offset_pointer(_state, _field, _type), \ 508 } 509 510 #define VMSTATE_STRUCT_VARRAY_POINTER_UINT16(_field, _state, _field_num, _vmsd, _type) { \ 511 .name = (stringify(_field)), \ 512 .version_id = 0, \ 513 .num_offset = vmstate_offset_value(_state, _field_num, uint16_t),\ 514 .size = sizeof(_type), \ 515 .vmsd = &(_vmsd), \ 516 .flags = VMS_POINTER | VMS_VARRAY_UINT16 | VMS_STRUCT, \ 517 .offset = vmstate_offset_pointer(_state, _field, _type), \ 518 } 519 520 #define VMSTATE_STATIC_BUFFER(_field, _state, _version, _test, _start, _size) { \ 521 .name = (stringify(_field)), \ 522 .version_id = (_version), \ 523 .field_exists = (_test), \ 524 .size = (_size - _start), \ 525 .info = &vmstate_info_buffer, \ 526 .flags = VMS_BUFFER, \ 527 .offset = vmstate_offset_buffer(_state, _field) + _start, \ 528 } 529 530 #define VMSTATE_BUFFER_MULTIPLY(_field, _state, _version, _test, _start, _field_size, _multiply) { \ 531 .name = (stringify(_field)), \ 532 .version_id = (_version), \ 533 .field_exists = (_test), \ 534 .size_offset = vmstate_offset_value(_state, _field_size, uint32_t),\ 535 .size = (_multiply), \ 536 .info = &vmstate_info_buffer, \ 537 .flags = VMS_VBUFFER|VMS_MULTIPLY, \ 538 .offset = offsetof(_state, _field), \ 539 .start = (_start), \ 540 } 541 542 #define VMSTATE_VBUFFER(_field, _state, _version, _test, _start, _field_size) { \ 543 .name = (stringify(_field)), \ 544 .version_id = (_version), \ 545 .field_exists = (_test), \ 546 .size_offset = vmstate_offset_value(_state, _field_size, int32_t),\ 547 .info = &vmstate_info_buffer, \ 548 .flags = VMS_VBUFFER|VMS_POINTER, \ 549 .offset = offsetof(_state, _field), \ 550 .start = (_start), \ 551 } 552 553 #define VMSTATE_VBUFFER_UINT32(_field, _state, _version, _test, _start, _field_size) { \ 554 .name = (stringify(_field)), \ 555 .version_id = (_version), \ 556 .field_exists = (_test), \ 557 .size_offset = vmstate_offset_value(_state, _field_size, uint32_t),\ 558 .info = &vmstate_info_buffer, \ 559 .flags = VMS_VBUFFER|VMS_POINTER, \ 560 .offset = offsetof(_state, _field), \ 561 .start = (_start), \ 562 } 563 564 #define VMSTATE_BUFFER_UNSAFE_INFO(_field, _state, _version, _info, _size) { \ 565 .name = (stringify(_field)), \ 566 .version_id = (_version), \ 567 .size = (_size), \ 568 .info = &(_info), \ 569 .flags = VMS_BUFFER, \ 570 .offset = offsetof(_state, _field), \ 571 } 572 573 #define VMSTATE_UNUSED_BUFFER(_test, _version, _size) { \ 574 .name = "unused", \ 575 .field_exists = (_test), \ 576 .version_id = (_version), \ 577 .size = (_size), \ 578 .info = &vmstate_info_unused_buffer, \ 579 .flags = VMS_BUFFER, \ 580 } 581 extern const VMStateDescription vmstate_pci_device; 582 583 #define VMSTATE_PCI_DEVICE(_field, _state) { \ 584 .name = (stringify(_field)), \ 585 .size = sizeof(PCIDevice), \ 586 .vmsd = &vmstate_pci_device, \ 587 .flags = VMS_STRUCT, \ 588 .offset = vmstate_offset_value(_state, _field, PCIDevice), \ 589 } 590 591 extern const VMStateDescription vmstate_pcie_device; 592 593 #define VMSTATE_PCIE_DEVICE(_field, _state) { \ 594 .name = (stringify(_field)), \ 595 .version_id = 2, \ 596 .size = sizeof(PCIDevice), \ 597 .vmsd = &vmstate_pcie_device, \ 598 .flags = VMS_STRUCT, \ 599 .offset = vmstate_offset_value(_state, _field, PCIDevice), \ 600 } 601 602 extern const VMStateDescription vmstate_i2c_slave; 603 604 #define VMSTATE_I2C_SLAVE(_field, _state) { \ 605 .name = (stringify(_field)), \ 606 .size = sizeof(i2c_slave), \ 607 .vmsd = &vmstate_i2c_slave, \ 608 .flags = VMS_STRUCT, \ 609 .offset = vmstate_offset_value(_state, _field, i2c_slave), \ 610 } 611 612 extern const VMStateDescription vmstate_usb_device; 613 614 #define VMSTATE_USB_DEVICE(_field, _state) { \ 615 .name = (stringify(_field)), \ 616 .size = sizeof(USBDevice), \ 617 .vmsd = &vmstate_usb_device, \ 618 .flags = VMS_STRUCT, \ 619 .offset = vmstate_offset_value(_state, _field, USBDevice), \ 620 } 621 622 #define vmstate_offset_macaddr(_state, _field) \ 623 vmstate_offset_array(_state, _field.a, uint8_t, \ 624 sizeof(typeof_field(_state, _field))) 625 626 #define VMSTATE_MACADDR(_field, _state) { \ 627 .name = (stringify(_field)), \ 628 .size = sizeof(MACAddr), \ 629 .info = &vmstate_info_buffer, \ 630 .flags = VMS_BUFFER, \ 631 .offset = vmstate_offset_macaddr(_state, _field), \ 632 } 633 634 /* _f : field name 635 _f_n : num of elements field_name 636 _n : num of elements 637 _s : struct state name 638 _v : version 639 */ 640 641 #define VMSTATE_SINGLE(_field, _state, _version, _info, _type) \ 642 VMSTATE_SINGLE_TEST(_field, _state, NULL, _version, _info, _type) 643 644 #define VMSTATE_STRUCT(_field, _state, _version, _vmsd, _type) \ 645 VMSTATE_STRUCT_TEST(_field, _state, NULL, _version, _vmsd, _type) 646 647 #define VMSTATE_STRUCT_POINTER(_field, _state, _vmsd, _type) \ 648 VMSTATE_STRUCT_POINTER_TEST(_field, _state, NULL, _vmsd, _type) 649 650 #define VMSTATE_STRUCT_ARRAY(_field, _state, _num, _version, _vmsd, _type) \ 651 VMSTATE_STRUCT_ARRAY_TEST(_field, _state, _num, NULL, _version, \ 652 _vmsd, _type) 653 654 #define VMSTATE_BOOL_V(_f, _s, _v) \ 655 VMSTATE_SINGLE(_f, _s, _v, vmstate_info_bool, bool) 656 657 #define VMSTATE_INT8_V(_f, _s, _v) \ 658 VMSTATE_SINGLE(_f, _s, _v, vmstate_info_int8, int8_t) 659 #define VMSTATE_INT16_V(_f, _s, _v) \ 660 VMSTATE_SINGLE(_f, _s, _v, vmstate_info_int16, int16_t) 661 #define VMSTATE_INT32_V(_f, _s, _v) \ 662 VMSTATE_SINGLE(_f, _s, _v, vmstate_info_int32, int32_t) 663 #define VMSTATE_INT64_V(_f, _s, _v) \ 664 VMSTATE_SINGLE(_f, _s, _v, vmstate_info_int64, int64_t) 665 666 #define VMSTATE_UINT8_V(_f, _s, _v) \ 667 VMSTATE_SINGLE(_f, _s, _v, vmstate_info_uint8, uint8_t) 668 #define VMSTATE_UINT16_V(_f, _s, _v) \ 669 VMSTATE_SINGLE(_f, _s, _v, vmstate_info_uint16, uint16_t) 670 #define VMSTATE_UINT32_V(_f, _s, _v) \ 671 VMSTATE_SINGLE(_f, _s, _v, vmstate_info_uint32, uint32_t) 672 #define VMSTATE_UINT64_V(_f, _s, _v) \ 673 VMSTATE_SINGLE(_f, _s, _v, vmstate_info_uint64, uint64_t) 674 675 #define VMSTATE_BOOL(_f, _s) \ 676 VMSTATE_BOOL_V(_f, _s, 0) 677 678 #define VMSTATE_INT8(_f, _s) \ 679 VMSTATE_INT8_V(_f, _s, 0) 680 #define VMSTATE_INT16(_f, _s) \ 681 VMSTATE_INT16_V(_f, _s, 0) 682 #define VMSTATE_INT32(_f, _s) \ 683 VMSTATE_INT32_V(_f, _s, 0) 684 #define VMSTATE_INT64(_f, _s) \ 685 VMSTATE_INT64_V(_f, _s, 0) 686 687 #define VMSTATE_UINT8(_f, _s) \ 688 VMSTATE_UINT8_V(_f, _s, 0) 689 #define VMSTATE_UINT16(_f, _s) \ 690 VMSTATE_UINT16_V(_f, _s, 0) 691 #define VMSTATE_UINT32(_f, _s) \ 692 VMSTATE_UINT32_V(_f, _s, 0) 693 #define VMSTATE_UINT64(_f, _s) \ 694 VMSTATE_UINT64_V(_f, _s, 0) 695 696 #define VMSTATE_UINT8_EQUAL(_f, _s) \ 697 VMSTATE_SINGLE(_f, _s, 0, vmstate_info_uint8_equal, uint8_t) 698 699 #define VMSTATE_UINT16_EQUAL(_f, _s) \ 700 VMSTATE_SINGLE(_f, _s, 0, vmstate_info_uint16_equal, uint16_t) 701 702 #define VMSTATE_UINT16_EQUAL_V(_f, _s, _v) \ 703 VMSTATE_SINGLE(_f, _s, _v, vmstate_info_uint16_equal, uint16_t) 704 705 #define VMSTATE_INT32_EQUAL(_f, _s) \ 706 VMSTATE_SINGLE(_f, _s, 0, vmstate_info_int32_equal, int32_t) 707 708 #define VMSTATE_UINT32_EQUAL(_f, _s) \ 709 VMSTATE_SINGLE(_f, _s, 0, vmstate_info_uint32_equal, uint32_t) 710 711 #define VMSTATE_INT32_LE(_f, _s) \ 712 VMSTATE_SINGLE(_f, _s, 0, vmstate_info_int32_le, int32_t) 713 714 #define VMSTATE_UINT16_TEST(_f, _s, _t) \ 715 VMSTATE_SINGLE_TEST(_f, _s, _t, 0, vmstate_info_uint16, uint16_t) 716 717 #define VMSTATE_UINT32_TEST(_f, _s, _t) \ 718 VMSTATE_SINGLE_TEST(_f, _s, _t, 0, vmstate_info_uint32, uint32_t) 719 720 #define VMSTATE_TIMER_V(_f, _s, _v) \ 721 VMSTATE_POINTER(_f, _s, _v, vmstate_info_timer, QEMUTimer *) 722 723 #define VMSTATE_TIMER(_f, _s) \ 724 VMSTATE_TIMER_V(_f, _s, 0) 725 726 #define VMSTATE_TIMER_ARRAY(_f, _s, _n) \ 727 VMSTATE_ARRAY_OF_POINTER(_f, _s, _n, 0, vmstate_info_timer, QEMUTimer *) 728 729 #define VMSTATE_PTIMER_V(_f, _s, _v) \ 730 VMSTATE_POINTER(_f, _s, _v, vmstate_info_ptimer, ptimer_state *) 731 732 #define VMSTATE_PTIMER(_f, _s) \ 733 VMSTATE_PTIMER_V(_f, _s, 0) 734 735 #define VMSTATE_BOOL_ARRAY_V(_f, _s, _n, _v) \ 736 VMSTATE_ARRAY(_f, _s, _n, _v, vmstate_info_bool, bool) 737 738 #define VMSTATE_BOOL_ARRAY(_f, _s, _n) \ 739 VMSTATE_BOOL_ARRAY_V(_f, _s, _n, 0) 740 741 #define VMSTATE_UINT16_ARRAY_V(_f, _s, _n, _v) \ 742 VMSTATE_ARRAY(_f, _s, _n, _v, vmstate_info_uint16, uint16_t) 743 744 #define VMSTATE_UINT16_ARRAY(_f, _s, _n) \ 745 VMSTATE_UINT16_ARRAY_V(_f, _s, _n, 0) 746 747 #define VMSTATE_UINT8_ARRAY_V(_f, _s, _n, _v) \ 748 VMSTATE_ARRAY(_f, _s, _n, _v, vmstate_info_uint8, uint8_t) 749 750 #define VMSTATE_UINT8_ARRAY(_f, _s, _n) \ 751 VMSTATE_UINT8_ARRAY_V(_f, _s, _n, 0) 752 753 #define VMSTATE_UINT32_ARRAY_V(_f, _s, _n, _v) \ 754 VMSTATE_ARRAY(_f, _s, _n, _v, vmstate_info_uint32, uint32_t) 755 756 #define VMSTATE_UINT32_ARRAY(_f, _s, _n) \ 757 VMSTATE_UINT32_ARRAY_V(_f, _s, _n, 0) 758 759 #define VMSTATE_UINT64_ARRAY_V(_f, _s, _n, _v) \ 760 VMSTATE_ARRAY(_f, _s, _n, _v, vmstate_info_uint64, uint64_t) 761 762 #define VMSTATE_UINT64_ARRAY(_f, _s, _n) \ 763 VMSTATE_UINT64_ARRAY_V(_f, _s, _n, 0) 764 765 #define VMSTATE_INT16_ARRAY_V(_f, _s, _n, _v) \ 766 VMSTATE_ARRAY(_f, _s, _n, _v, vmstate_info_int16, int16_t) 767 768 #define VMSTATE_INT16_ARRAY(_f, _s, _n) \ 769 VMSTATE_INT16_ARRAY_V(_f, _s, _n, 0) 770 771 #define VMSTATE_INT32_ARRAY_V(_f, _s, _n, _v) \ 772 VMSTATE_ARRAY(_f, _s, _n, _v, vmstate_info_int32, int32_t) 773 774 #define VMSTATE_INT32_ARRAY(_f, _s, _n) \ 775 VMSTATE_INT32_ARRAY_V(_f, _s, _n, 0) 776 777 #define VMSTATE_UINT32_SUB_ARRAY(_f, _s, _start, _num) \ 778 VMSTATE_SUB_ARRAY(_f, _s, _start, _num, 0, vmstate_info_uint32, uint32_t) 779 780 #define VMSTATE_UINT32_ARRAY(_f, _s, _n) \ 781 VMSTATE_UINT32_ARRAY_V(_f, _s, _n, 0) 782 783 #define VMSTATE_BUFFER_V(_f, _s, _v) \ 784 VMSTATE_STATIC_BUFFER(_f, _s, _v, NULL, 0, sizeof(typeof_field(_s, _f))) 785 786 #define VMSTATE_BUFFER(_f, _s) \ 787 VMSTATE_BUFFER_V(_f, _s, 0) 788 789 #define VMSTATE_PARTIAL_BUFFER(_f, _s, _size) \ 790 VMSTATE_STATIC_BUFFER(_f, _s, 0, NULL, 0, _size) 791 792 #define VMSTATE_BUFFER_START_MIDDLE(_f, _s, _start) \ 793 VMSTATE_STATIC_BUFFER(_f, _s, 0, NULL, _start, sizeof(typeof_field(_s, _f))) 794 795 #define VMSTATE_PARTIAL_VBUFFER(_f, _s, _size) \ 796 VMSTATE_VBUFFER(_f, _s, 0, NULL, 0, _size) 797 798 #define VMSTATE_PARTIAL_VBUFFER_UINT32(_f, _s, _size) \ 799 VMSTATE_VBUFFER_UINT32(_f, _s, 0, NULL, 0, _size) 800 801 #define VMSTATE_SUB_VBUFFER(_f, _s, _start, _size) \ 802 VMSTATE_VBUFFER(_f, _s, 0, NULL, _start, _size) 803 804 #define VMSTATE_BUFFER_TEST(_f, _s, _test) \ 805 VMSTATE_STATIC_BUFFER(_f, _s, 0, _test, 0, sizeof(typeof_field(_s, _f))) 806 807 #define VMSTATE_BUFFER_UNSAFE(_field, _state, _version, _size) \ 808 VMSTATE_BUFFER_UNSAFE_INFO(_field, _state, _version, vmstate_info_buffer, _size) 809 810 #define VMSTATE_UNUSED_V(_v, _size) \ 811 VMSTATE_UNUSED_BUFFER(NULL, _v, _size) 812 813 #define VMSTATE_UNUSED(_size) \ 814 VMSTATE_UNUSED_V(0, _size) 815 816 #define VMSTATE_UNUSED_TEST(_test, _size) \ 817 VMSTATE_UNUSED_BUFFER(_test, 0, _size) 818 819 #ifdef NEED_CPU_H 820 #if TARGET_LONG_BITS == 64 821 #define VMSTATE_UINTTL_V(_f, _s, _v) \ 822 VMSTATE_UINT64_V(_f, _s, _v) 823 #define VMSTATE_UINTTL_ARRAY_V(_f, _s, _n, _v) \ 824 VMSTATE_UINT64_ARRAY_V(_f, _s, _n, _v) 825 #else 826 #define VMSTATE_UINTTL_V(_f, _s, _v) \ 827 VMSTATE_UINT32_V(_f, _s, _v) 828 #define VMSTATE_UINTTL_ARRAY_V(_f, _s, _n, _v) \ 829 VMSTATE_UINT32_ARRAY_V(_f, _s, _n, _v) 830 #endif 831 #define VMSTATE_UINTTL(_f, _s) \ 832 VMSTATE_UINTTL_V(_f, _s, 0) 833 #define VMSTATE_UINTTL_ARRAY(_f, _s, _n) \ 834 VMSTATE_UINTTL_ARRAY_V(_f, _s, _n, 0) 835 836 #endif 837 838 #define VMSTATE_END_OF_LIST() \ 839 {} 840 841 int vmstate_load_state(QEMUFile *f, const VMStateDescription *vmsd, 842 void *opaque, int version_id); 843 void vmstate_save_state(QEMUFile *f, const VMStateDescription *vmsd, 844 void *opaque); 845 int vmstate_register(DeviceState *dev, int instance_id, 846 const VMStateDescription *vmsd, void *base); 847 int vmstate_register_with_alias_id(DeviceState *dev, int instance_id, 848 const VMStateDescription *vmsd, 849 void *base, int alias_id, 850 int required_for_version); 851 void vmstate_unregister(DeviceState *dev, const VMStateDescription *vmsd, 852 void *opaque); 853 #endif 854