1 /* 2 * Migration support for VFIO devices 3 * 4 * Copyright NVIDIA, Inc. 2020 5 * 6 * This work is licensed under the terms of the GNU GPL, version 2. See 7 * the COPYING file in the top-level directory. 8 */ 9 10 #include "qemu/osdep.h" 11 #include "qemu/main-loop.h" 12 #include "qemu/cutils.h" 13 #include "qemu/units.h" 14 #include "qemu/error-report.h" 15 #include <linux/vfio.h> 16 #include <sys/ioctl.h> 17 18 #include "sysemu/runstate.h" 19 #include "hw/vfio/vfio-common.h" 20 #include "migration/migration.h" 21 #include "migration/options.h" 22 #include "migration/savevm.h" 23 #include "migration/vmstate.h" 24 #include "migration/qemu-file.h" 25 #include "migration/register.h" 26 #include "migration/blocker.h" 27 #include "migration/misc.h" 28 #include "qapi/error.h" 29 #include "exec/ramlist.h" 30 #include "exec/ram_addr.h" 31 #include "pci.h" 32 #include "trace.h" 33 #include "hw/hw.h" 34 35 /* 36 * Flags to be used as unique delimiters for VFIO devices in the migration 37 * stream. These flags are composed as: 38 * 0xffffffff => MSB 32-bit all 1s 39 * 0xef10 => Magic ID, represents emulated (virtual) function IO 40 * 0x0000 => 16-bits reserved for flags 41 * 42 * The beginning of state information is marked by _DEV_CONFIG_STATE, 43 * _DEV_SETUP_STATE, or _DEV_DATA_STATE, respectively. The end of a 44 * certain state information is marked by _END_OF_STATE. 45 */ 46 #define VFIO_MIG_FLAG_END_OF_STATE (0xffffffffef100001ULL) 47 #define VFIO_MIG_FLAG_DEV_CONFIG_STATE (0xffffffffef100002ULL) 48 #define VFIO_MIG_FLAG_DEV_SETUP_STATE (0xffffffffef100003ULL) 49 #define VFIO_MIG_FLAG_DEV_DATA_STATE (0xffffffffef100004ULL) 50 #define VFIO_MIG_FLAG_DEV_INIT_DATA_SENT (0xffffffffef100005ULL) 51 52 /* 53 * This is an arbitrary size based on migration of mlx5 devices, where typically 54 * total device migration size is on the order of 100s of MB. Testing with 55 * larger values, e.g. 128MB and 1GB, did not show a performance improvement. 56 */ 57 #define VFIO_MIG_DEFAULT_DATA_BUFFER_SIZE (1 * MiB) 58 59 static int64_t bytes_transferred; 60 61 static const char *mig_state_to_str(enum vfio_device_mig_state state) 62 { 63 switch (state) { 64 case VFIO_DEVICE_STATE_ERROR: 65 return "ERROR"; 66 case VFIO_DEVICE_STATE_STOP: 67 return "STOP"; 68 case VFIO_DEVICE_STATE_RUNNING: 69 return "RUNNING"; 70 case VFIO_DEVICE_STATE_STOP_COPY: 71 return "STOP_COPY"; 72 case VFIO_DEVICE_STATE_RESUMING: 73 return "RESUMING"; 74 case VFIO_DEVICE_STATE_PRE_COPY: 75 return "PRE_COPY"; 76 default: 77 return "UNKNOWN STATE"; 78 } 79 } 80 81 static int vfio_migration_set_state(VFIODevice *vbasedev, 82 enum vfio_device_mig_state new_state, 83 enum vfio_device_mig_state recover_state) 84 { 85 VFIOMigration *migration = vbasedev->migration; 86 uint64_t buf[DIV_ROUND_UP(sizeof(struct vfio_device_feature) + 87 sizeof(struct vfio_device_feature_mig_state), 88 sizeof(uint64_t))] = {}; 89 struct vfio_device_feature *feature = (struct vfio_device_feature *)buf; 90 struct vfio_device_feature_mig_state *mig_state = 91 (struct vfio_device_feature_mig_state *)feature->data; 92 int ret; 93 94 feature->argsz = sizeof(buf); 95 feature->flags = 96 VFIO_DEVICE_FEATURE_SET | VFIO_DEVICE_FEATURE_MIG_DEVICE_STATE; 97 mig_state->device_state = new_state; 98 if (ioctl(vbasedev->fd, VFIO_DEVICE_FEATURE, feature)) { 99 /* Try to set the device in some good state */ 100 ret = -errno; 101 102 if (recover_state == VFIO_DEVICE_STATE_ERROR) { 103 error_report("%s: Failed setting device state to %s, err: %s. " 104 "Recover state is ERROR. Resetting device", 105 vbasedev->name, mig_state_to_str(new_state), 106 strerror(errno)); 107 108 goto reset_device; 109 } 110 111 error_report( 112 "%s: Failed setting device state to %s, err: %s. Setting device in recover state %s", 113 vbasedev->name, mig_state_to_str(new_state), 114 strerror(errno), mig_state_to_str(recover_state)); 115 116 mig_state->device_state = recover_state; 117 if (ioctl(vbasedev->fd, VFIO_DEVICE_FEATURE, feature)) { 118 ret = -errno; 119 error_report( 120 "%s: Failed setting device in recover state, err: %s. Resetting device", 121 vbasedev->name, strerror(errno)); 122 123 goto reset_device; 124 } 125 126 migration->device_state = recover_state; 127 128 return ret; 129 } 130 131 migration->device_state = new_state; 132 if (mig_state->data_fd != -1) { 133 if (migration->data_fd != -1) { 134 /* 135 * This can happen if the device is asynchronously reset and 136 * terminates a data transfer. 137 */ 138 error_report("%s: data_fd out of sync", vbasedev->name); 139 close(mig_state->data_fd); 140 141 return -EBADF; 142 } 143 144 migration->data_fd = mig_state->data_fd; 145 } 146 147 trace_vfio_migration_set_state(vbasedev->name, mig_state_to_str(new_state)); 148 149 return 0; 150 151 reset_device: 152 if (ioctl(vbasedev->fd, VFIO_DEVICE_RESET)) { 153 hw_error("%s: Failed resetting device, err: %s", vbasedev->name, 154 strerror(errno)); 155 } 156 157 migration->device_state = VFIO_DEVICE_STATE_RUNNING; 158 159 return ret; 160 } 161 162 static int vfio_load_buffer(QEMUFile *f, VFIODevice *vbasedev, 163 uint64_t data_size) 164 { 165 VFIOMigration *migration = vbasedev->migration; 166 int ret; 167 168 ret = qemu_file_get_to_fd(f, migration->data_fd, data_size); 169 trace_vfio_load_state_device_data(vbasedev->name, data_size, ret); 170 171 return ret; 172 } 173 174 static int vfio_save_device_config_state(QEMUFile *f, void *opaque) 175 { 176 VFIODevice *vbasedev = opaque; 177 178 qemu_put_be64(f, VFIO_MIG_FLAG_DEV_CONFIG_STATE); 179 180 if (vbasedev->ops && vbasedev->ops->vfio_save_config) { 181 vbasedev->ops->vfio_save_config(vbasedev, f); 182 } 183 184 qemu_put_be64(f, VFIO_MIG_FLAG_END_OF_STATE); 185 186 trace_vfio_save_device_config_state(vbasedev->name); 187 188 return qemu_file_get_error(f); 189 } 190 191 static int vfio_load_device_config_state(QEMUFile *f, void *opaque) 192 { 193 VFIODevice *vbasedev = opaque; 194 uint64_t data; 195 196 if (vbasedev->ops && vbasedev->ops->vfio_load_config) { 197 int ret; 198 199 ret = vbasedev->ops->vfio_load_config(vbasedev, f); 200 if (ret) { 201 error_report("%s: Failed to load device config space", 202 vbasedev->name); 203 return ret; 204 } 205 } 206 207 data = qemu_get_be64(f); 208 if (data != VFIO_MIG_FLAG_END_OF_STATE) { 209 error_report("%s: Failed loading device config space, " 210 "end flag incorrect 0x%"PRIx64, vbasedev->name, data); 211 return -EINVAL; 212 } 213 214 trace_vfio_load_device_config_state(vbasedev->name); 215 return qemu_file_get_error(f); 216 } 217 218 static void vfio_migration_cleanup(VFIODevice *vbasedev) 219 { 220 VFIOMigration *migration = vbasedev->migration; 221 222 close(migration->data_fd); 223 migration->data_fd = -1; 224 } 225 226 static int vfio_query_stop_copy_size(VFIODevice *vbasedev, 227 uint64_t *stop_copy_size) 228 { 229 uint64_t buf[DIV_ROUND_UP(sizeof(struct vfio_device_feature) + 230 sizeof(struct vfio_device_feature_mig_data_size), 231 sizeof(uint64_t))] = {}; 232 struct vfio_device_feature *feature = (struct vfio_device_feature *)buf; 233 struct vfio_device_feature_mig_data_size *mig_data_size = 234 (struct vfio_device_feature_mig_data_size *)feature->data; 235 236 feature->argsz = sizeof(buf); 237 feature->flags = 238 VFIO_DEVICE_FEATURE_GET | VFIO_DEVICE_FEATURE_MIG_DATA_SIZE; 239 240 if (ioctl(vbasedev->fd, VFIO_DEVICE_FEATURE, feature)) { 241 return -errno; 242 } 243 244 *stop_copy_size = mig_data_size->stop_copy_length; 245 246 return 0; 247 } 248 249 static int vfio_query_precopy_size(VFIOMigration *migration) 250 { 251 struct vfio_precopy_info precopy = { 252 .argsz = sizeof(precopy), 253 }; 254 255 migration->precopy_init_size = 0; 256 migration->precopy_dirty_size = 0; 257 258 if (ioctl(migration->data_fd, VFIO_MIG_GET_PRECOPY_INFO, &precopy)) { 259 return -errno; 260 } 261 262 migration->precopy_init_size = precopy.initial_bytes; 263 migration->precopy_dirty_size = precopy.dirty_bytes; 264 265 return 0; 266 } 267 268 /* Returns the size of saved data on success and -errno on error */ 269 static ssize_t vfio_save_block(QEMUFile *f, VFIOMigration *migration) 270 { 271 ssize_t data_size; 272 273 data_size = read(migration->data_fd, migration->data_buffer, 274 migration->data_buffer_size); 275 if (data_size < 0) { 276 /* 277 * Pre-copy emptied all the device state for now. For more information, 278 * please refer to the Linux kernel VFIO uAPI. 279 */ 280 if (errno == ENOMSG) { 281 return 0; 282 } 283 284 return -errno; 285 } 286 if (data_size == 0) { 287 return 0; 288 } 289 290 qemu_put_be64(f, VFIO_MIG_FLAG_DEV_DATA_STATE); 291 qemu_put_be64(f, data_size); 292 qemu_put_buffer(f, migration->data_buffer, data_size); 293 bytes_transferred += data_size; 294 295 trace_vfio_save_block(migration->vbasedev->name, data_size); 296 297 return qemu_file_get_error(f) ?: data_size; 298 } 299 300 static void vfio_update_estimated_pending_data(VFIOMigration *migration, 301 uint64_t data_size) 302 { 303 if (!data_size) { 304 /* 305 * Pre-copy emptied all the device state for now, update estimated sizes 306 * accordingly. 307 */ 308 migration->precopy_init_size = 0; 309 migration->precopy_dirty_size = 0; 310 311 return; 312 } 313 314 if (migration->precopy_init_size) { 315 uint64_t init_size = MIN(migration->precopy_init_size, data_size); 316 317 migration->precopy_init_size -= init_size; 318 data_size -= init_size; 319 } 320 321 migration->precopy_dirty_size -= MIN(migration->precopy_dirty_size, 322 data_size); 323 } 324 325 static bool vfio_precopy_supported(VFIODevice *vbasedev) 326 { 327 VFIOMigration *migration = vbasedev->migration; 328 329 return migration->mig_flags & VFIO_MIGRATION_PRE_COPY; 330 } 331 332 /* ---------------------------------------------------------------------- */ 333 334 static int vfio_save_setup(QEMUFile *f, void *opaque) 335 { 336 VFIODevice *vbasedev = opaque; 337 VFIOMigration *migration = vbasedev->migration; 338 uint64_t stop_copy_size = VFIO_MIG_DEFAULT_DATA_BUFFER_SIZE; 339 340 qemu_put_be64(f, VFIO_MIG_FLAG_DEV_SETUP_STATE); 341 342 vfio_query_stop_copy_size(vbasedev, &stop_copy_size); 343 migration->data_buffer_size = MIN(VFIO_MIG_DEFAULT_DATA_BUFFER_SIZE, 344 stop_copy_size); 345 migration->data_buffer = g_try_malloc0(migration->data_buffer_size); 346 if (!migration->data_buffer) { 347 error_report("%s: Failed to allocate migration data buffer", 348 vbasedev->name); 349 return -ENOMEM; 350 } 351 352 if (vfio_precopy_supported(vbasedev)) { 353 int ret; 354 355 switch (migration->device_state) { 356 case VFIO_DEVICE_STATE_RUNNING: 357 ret = vfio_migration_set_state(vbasedev, VFIO_DEVICE_STATE_PRE_COPY, 358 VFIO_DEVICE_STATE_RUNNING); 359 if (ret) { 360 return ret; 361 } 362 363 vfio_query_precopy_size(migration); 364 365 break; 366 case VFIO_DEVICE_STATE_STOP: 367 /* vfio_save_complete_precopy() will go to STOP_COPY */ 368 break; 369 default: 370 return -EINVAL; 371 } 372 } 373 374 trace_vfio_save_setup(vbasedev->name, migration->data_buffer_size); 375 376 qemu_put_be64(f, VFIO_MIG_FLAG_END_OF_STATE); 377 378 return qemu_file_get_error(f); 379 } 380 381 static void vfio_save_cleanup(void *opaque) 382 { 383 VFIODevice *vbasedev = opaque; 384 VFIOMigration *migration = vbasedev->migration; 385 386 /* 387 * Changing device state from STOP_COPY to STOP can take time. Do it here, 388 * after migration has completed, so it won't increase downtime. 389 */ 390 if (migration->device_state == VFIO_DEVICE_STATE_STOP_COPY) { 391 /* 392 * If setting the device in STOP state fails, the device should be 393 * reset. To do so, use ERROR state as a recover state. 394 */ 395 vfio_migration_set_state(vbasedev, VFIO_DEVICE_STATE_STOP, 396 VFIO_DEVICE_STATE_ERROR); 397 } 398 399 g_free(migration->data_buffer); 400 migration->data_buffer = NULL; 401 migration->precopy_init_size = 0; 402 migration->precopy_dirty_size = 0; 403 migration->initial_data_sent = false; 404 vfio_migration_cleanup(vbasedev); 405 trace_vfio_save_cleanup(vbasedev->name); 406 } 407 408 static void vfio_state_pending_estimate(void *opaque, uint64_t *must_precopy, 409 uint64_t *can_postcopy) 410 { 411 VFIODevice *vbasedev = opaque; 412 VFIOMigration *migration = vbasedev->migration; 413 414 if (migration->device_state != VFIO_DEVICE_STATE_PRE_COPY) { 415 return; 416 } 417 418 *must_precopy += 419 migration->precopy_init_size + migration->precopy_dirty_size; 420 421 trace_vfio_state_pending_estimate(vbasedev->name, *must_precopy, 422 *can_postcopy, 423 migration->precopy_init_size, 424 migration->precopy_dirty_size); 425 } 426 427 /* 428 * Migration size of VFIO devices can be as little as a few KBs or as big as 429 * many GBs. This value should be big enough to cover the worst case. 430 */ 431 #define VFIO_MIG_STOP_COPY_SIZE (100 * GiB) 432 433 static void vfio_state_pending_exact(void *opaque, uint64_t *must_precopy, 434 uint64_t *can_postcopy) 435 { 436 VFIODevice *vbasedev = opaque; 437 VFIOMigration *migration = vbasedev->migration; 438 uint64_t stop_copy_size = VFIO_MIG_STOP_COPY_SIZE; 439 440 /* 441 * If getting pending migration size fails, VFIO_MIG_STOP_COPY_SIZE is 442 * reported so downtime limit won't be violated. 443 */ 444 vfio_query_stop_copy_size(vbasedev, &stop_copy_size); 445 *must_precopy += stop_copy_size; 446 447 if (migration->device_state == VFIO_DEVICE_STATE_PRE_COPY) { 448 vfio_query_precopy_size(migration); 449 450 *must_precopy += 451 migration->precopy_init_size + migration->precopy_dirty_size; 452 } 453 454 trace_vfio_state_pending_exact(vbasedev->name, *must_precopy, *can_postcopy, 455 stop_copy_size, migration->precopy_init_size, 456 migration->precopy_dirty_size); 457 } 458 459 static bool vfio_is_active_iterate(void *opaque) 460 { 461 VFIODevice *vbasedev = opaque; 462 VFIOMigration *migration = vbasedev->migration; 463 464 return migration->device_state == VFIO_DEVICE_STATE_PRE_COPY; 465 } 466 467 static int vfio_save_iterate(QEMUFile *f, void *opaque) 468 { 469 VFIODevice *vbasedev = opaque; 470 VFIOMigration *migration = vbasedev->migration; 471 ssize_t data_size; 472 473 data_size = vfio_save_block(f, migration); 474 if (data_size < 0) { 475 return data_size; 476 } 477 478 vfio_update_estimated_pending_data(migration, data_size); 479 480 if (migrate_switchover_ack() && !migration->precopy_init_size && 481 !migration->initial_data_sent) { 482 qemu_put_be64(f, VFIO_MIG_FLAG_DEV_INIT_DATA_SENT); 483 migration->initial_data_sent = true; 484 } else { 485 qemu_put_be64(f, VFIO_MIG_FLAG_END_OF_STATE); 486 } 487 488 trace_vfio_save_iterate(vbasedev->name, migration->precopy_init_size, 489 migration->precopy_dirty_size); 490 491 /* 492 * A VFIO device's pre-copy dirty_bytes is not guaranteed to reach zero. 493 * Return 1 so following handlers will not be potentially blocked. 494 */ 495 return 1; 496 } 497 498 static int vfio_save_complete_precopy(QEMUFile *f, void *opaque) 499 { 500 VFIODevice *vbasedev = opaque; 501 ssize_t data_size; 502 int ret; 503 504 /* We reach here with device state STOP or STOP_COPY only */ 505 ret = vfio_migration_set_state(vbasedev, VFIO_DEVICE_STATE_STOP_COPY, 506 VFIO_DEVICE_STATE_STOP); 507 if (ret) { 508 return ret; 509 } 510 511 do { 512 data_size = vfio_save_block(f, vbasedev->migration); 513 if (data_size < 0) { 514 return data_size; 515 } 516 } while (data_size); 517 518 qemu_put_be64(f, VFIO_MIG_FLAG_END_OF_STATE); 519 ret = qemu_file_get_error(f); 520 if (ret) { 521 return ret; 522 } 523 524 trace_vfio_save_complete_precopy(vbasedev->name, ret); 525 526 return ret; 527 } 528 529 static void vfio_save_state(QEMUFile *f, void *opaque) 530 { 531 VFIODevice *vbasedev = opaque; 532 int ret; 533 534 ret = vfio_save_device_config_state(f, opaque); 535 if (ret) { 536 error_report("%s: Failed to save device config space", 537 vbasedev->name); 538 qemu_file_set_error(f, ret); 539 } 540 } 541 542 static int vfio_load_setup(QEMUFile *f, void *opaque) 543 { 544 VFIODevice *vbasedev = opaque; 545 546 return vfio_migration_set_state(vbasedev, VFIO_DEVICE_STATE_RESUMING, 547 vbasedev->migration->device_state); 548 } 549 550 static int vfio_load_cleanup(void *opaque) 551 { 552 VFIODevice *vbasedev = opaque; 553 554 vfio_migration_cleanup(vbasedev); 555 trace_vfio_load_cleanup(vbasedev->name); 556 557 return 0; 558 } 559 560 static int vfio_load_state(QEMUFile *f, void *opaque, int version_id) 561 { 562 VFIODevice *vbasedev = opaque; 563 int ret = 0; 564 uint64_t data; 565 566 data = qemu_get_be64(f); 567 while (data != VFIO_MIG_FLAG_END_OF_STATE) { 568 569 trace_vfio_load_state(vbasedev->name, data); 570 571 switch (data) { 572 case VFIO_MIG_FLAG_DEV_CONFIG_STATE: 573 { 574 return vfio_load_device_config_state(f, opaque); 575 } 576 case VFIO_MIG_FLAG_DEV_SETUP_STATE: 577 { 578 data = qemu_get_be64(f); 579 if (data == VFIO_MIG_FLAG_END_OF_STATE) { 580 return ret; 581 } else { 582 error_report("%s: SETUP STATE: EOS not found 0x%"PRIx64, 583 vbasedev->name, data); 584 return -EINVAL; 585 } 586 break; 587 } 588 case VFIO_MIG_FLAG_DEV_DATA_STATE: 589 { 590 uint64_t data_size = qemu_get_be64(f); 591 592 if (data_size) { 593 ret = vfio_load_buffer(f, vbasedev, data_size); 594 if (ret < 0) { 595 return ret; 596 } 597 } 598 break; 599 } 600 case VFIO_MIG_FLAG_DEV_INIT_DATA_SENT: 601 { 602 if (!vfio_precopy_supported(vbasedev) || 603 !migrate_switchover_ack()) { 604 error_report("%s: Received INIT_DATA_SENT but switchover ack " 605 "is not used", vbasedev->name); 606 return -EINVAL; 607 } 608 609 ret = qemu_loadvm_approve_switchover(); 610 if (ret) { 611 error_report( 612 "%s: qemu_loadvm_approve_switchover failed, err=%d (%s)", 613 vbasedev->name, ret, strerror(-ret)); 614 } 615 616 return ret; 617 } 618 default: 619 error_report("%s: Unknown tag 0x%"PRIx64, vbasedev->name, data); 620 return -EINVAL; 621 } 622 623 data = qemu_get_be64(f); 624 ret = qemu_file_get_error(f); 625 if (ret) { 626 return ret; 627 } 628 } 629 return ret; 630 } 631 632 static bool vfio_switchover_ack_needed(void *opaque) 633 { 634 VFIODevice *vbasedev = opaque; 635 636 return vfio_precopy_supported(vbasedev); 637 } 638 639 static const SaveVMHandlers savevm_vfio_handlers = { 640 .save_setup = vfio_save_setup, 641 .save_cleanup = vfio_save_cleanup, 642 .state_pending_estimate = vfio_state_pending_estimate, 643 .state_pending_exact = vfio_state_pending_exact, 644 .is_active_iterate = vfio_is_active_iterate, 645 .save_live_iterate = vfio_save_iterate, 646 .save_live_complete_precopy = vfio_save_complete_precopy, 647 .save_state = vfio_save_state, 648 .load_setup = vfio_load_setup, 649 .load_cleanup = vfio_load_cleanup, 650 .load_state = vfio_load_state, 651 .switchover_ack_needed = vfio_switchover_ack_needed, 652 }; 653 654 /* ---------------------------------------------------------------------- */ 655 656 static void vfio_vmstate_change(void *opaque, bool running, RunState state) 657 { 658 VFIODevice *vbasedev = opaque; 659 VFIOMigration *migration = vbasedev->migration; 660 enum vfio_device_mig_state new_state; 661 int ret; 662 663 if (running) { 664 new_state = VFIO_DEVICE_STATE_RUNNING; 665 } else { 666 new_state = 667 (migration->device_state == VFIO_DEVICE_STATE_PRE_COPY && 668 (state == RUN_STATE_FINISH_MIGRATE || state == RUN_STATE_PAUSED)) ? 669 VFIO_DEVICE_STATE_STOP_COPY : 670 VFIO_DEVICE_STATE_STOP; 671 } 672 673 /* 674 * If setting the device in new_state fails, the device should be reset. 675 * To do so, use ERROR state as a recover state. 676 */ 677 ret = vfio_migration_set_state(vbasedev, new_state, 678 VFIO_DEVICE_STATE_ERROR); 679 if (ret) { 680 /* 681 * Migration should be aborted in this case, but vm_state_notify() 682 * currently does not support reporting failures. 683 */ 684 if (migrate_get_current()->to_dst_file) { 685 qemu_file_set_error(migrate_get_current()->to_dst_file, ret); 686 } 687 } 688 689 trace_vfio_vmstate_change(vbasedev->name, running, RunState_str(state), 690 mig_state_to_str(new_state)); 691 } 692 693 static void vfio_migration_state_notifier(Notifier *notifier, void *data) 694 { 695 MigrationState *s = data; 696 VFIOMigration *migration = container_of(notifier, VFIOMigration, 697 migration_state); 698 VFIODevice *vbasedev = migration->vbasedev; 699 700 trace_vfio_migration_state_notifier(vbasedev->name, 701 MigrationStatus_str(s->state)); 702 703 switch (s->state) { 704 case MIGRATION_STATUS_CANCELLING: 705 case MIGRATION_STATUS_CANCELLED: 706 case MIGRATION_STATUS_FAILED: 707 /* 708 * If setting the device in RUNNING state fails, the device should 709 * be reset. To do so, use ERROR state as a recover state. 710 */ 711 vfio_migration_set_state(vbasedev, VFIO_DEVICE_STATE_RUNNING, 712 VFIO_DEVICE_STATE_ERROR); 713 } 714 } 715 716 static void vfio_migration_free(VFIODevice *vbasedev) 717 { 718 g_free(vbasedev->migration); 719 vbasedev->migration = NULL; 720 } 721 722 static int vfio_migration_query_flags(VFIODevice *vbasedev, uint64_t *mig_flags) 723 { 724 uint64_t buf[DIV_ROUND_UP(sizeof(struct vfio_device_feature) + 725 sizeof(struct vfio_device_feature_migration), 726 sizeof(uint64_t))] = {}; 727 struct vfio_device_feature *feature = (struct vfio_device_feature *)buf; 728 struct vfio_device_feature_migration *mig = 729 (struct vfio_device_feature_migration *)feature->data; 730 731 feature->argsz = sizeof(buf); 732 feature->flags = VFIO_DEVICE_FEATURE_GET | VFIO_DEVICE_FEATURE_MIGRATION; 733 if (ioctl(vbasedev->fd, VFIO_DEVICE_FEATURE, feature)) { 734 return -errno; 735 } 736 737 *mig_flags = mig->flags; 738 739 return 0; 740 } 741 742 static bool vfio_dma_logging_supported(VFIODevice *vbasedev) 743 { 744 uint64_t buf[DIV_ROUND_UP(sizeof(struct vfio_device_feature), 745 sizeof(uint64_t))] = {}; 746 struct vfio_device_feature *feature = (struct vfio_device_feature *)buf; 747 748 feature->argsz = sizeof(buf); 749 feature->flags = VFIO_DEVICE_FEATURE_PROBE | 750 VFIO_DEVICE_FEATURE_DMA_LOGGING_START; 751 752 return !ioctl(vbasedev->fd, VFIO_DEVICE_FEATURE, feature); 753 } 754 755 static int vfio_migration_init(VFIODevice *vbasedev) 756 { 757 int ret; 758 Object *obj; 759 VFIOMigration *migration; 760 char id[256] = ""; 761 g_autofree char *path = NULL, *oid = NULL; 762 uint64_t mig_flags = 0; 763 764 if (!vbasedev->ops->vfio_get_object) { 765 return -EINVAL; 766 } 767 768 obj = vbasedev->ops->vfio_get_object(vbasedev); 769 if (!obj) { 770 return -EINVAL; 771 } 772 773 ret = vfio_migration_query_flags(vbasedev, &mig_flags); 774 if (ret) { 775 return ret; 776 } 777 778 /* Basic migration functionality must be supported */ 779 if (!(mig_flags & VFIO_MIGRATION_STOP_COPY)) { 780 return -EOPNOTSUPP; 781 } 782 783 vbasedev->migration = g_new0(VFIOMigration, 1); 784 migration = vbasedev->migration; 785 migration->vbasedev = vbasedev; 786 migration->device_state = VFIO_DEVICE_STATE_RUNNING; 787 migration->data_fd = -1; 788 migration->mig_flags = mig_flags; 789 790 vbasedev->dirty_pages_supported = vfio_dma_logging_supported(vbasedev); 791 792 oid = vmstate_if_get_id(VMSTATE_IF(DEVICE(obj))); 793 if (oid) { 794 path = g_strdup_printf("%s/vfio", oid); 795 } else { 796 path = g_strdup("vfio"); 797 } 798 strpadcpy(id, sizeof(id), path, '\0'); 799 800 register_savevm_live(id, VMSTATE_INSTANCE_ID_ANY, 1, &savevm_vfio_handlers, 801 vbasedev); 802 803 migration->vm_state = qdev_add_vm_change_state_handler(vbasedev->dev, 804 vfio_vmstate_change, 805 vbasedev); 806 migration->migration_state.notify = vfio_migration_state_notifier; 807 add_migration_state_change_notifier(&migration->migration_state); 808 809 return 0; 810 } 811 812 static void vfio_migration_deinit(VFIODevice *vbasedev) 813 { 814 VFIOMigration *migration = vbasedev->migration; 815 816 remove_migration_state_change_notifier(&migration->migration_state); 817 qemu_del_vm_change_state_handler(migration->vm_state); 818 unregister_savevm(VMSTATE_IF(vbasedev->dev), "vfio", vbasedev); 819 vfio_migration_free(vbasedev); 820 vfio_unblock_multiple_devices_migration(); 821 } 822 823 static int vfio_block_migration(VFIODevice *vbasedev, Error *err, Error **errp) 824 { 825 int ret; 826 827 if (vbasedev->enable_migration == ON_OFF_AUTO_ON) { 828 error_propagate(errp, err); 829 return -EINVAL; 830 } 831 832 vbasedev->migration_blocker = error_copy(err); 833 error_free(err); 834 835 ret = migrate_add_blocker(vbasedev->migration_blocker, errp); 836 if (ret < 0) { 837 error_free(vbasedev->migration_blocker); 838 vbasedev->migration_blocker = NULL; 839 } 840 841 return ret; 842 } 843 844 /* ---------------------------------------------------------------------- */ 845 846 int64_t vfio_mig_bytes_transferred(void) 847 { 848 return bytes_transferred; 849 } 850 851 void vfio_reset_bytes_transferred(void) 852 { 853 bytes_transferred = 0; 854 } 855 856 /* 857 * Return true when either migration initialized or blocker registered. 858 * Currently only return false when adding blocker fails which will 859 * de-register vfio device. 860 */ 861 bool vfio_migration_realize(VFIODevice *vbasedev, Error **errp) 862 { 863 Error *err = NULL; 864 int ret; 865 866 if (vbasedev->enable_migration == ON_OFF_AUTO_OFF) { 867 error_setg(&err, "%s: Migration is disabled for VFIO device", 868 vbasedev->name); 869 return !vfio_block_migration(vbasedev, err, errp); 870 } 871 872 ret = vfio_migration_init(vbasedev); 873 if (ret) { 874 if (ret == -ENOTTY) { 875 error_setg(&err, "%s: VFIO migration is not supported in kernel", 876 vbasedev->name); 877 } else { 878 error_setg(&err, 879 "%s: Migration couldn't be initialized for VFIO device, " 880 "err: %d (%s)", 881 vbasedev->name, ret, strerror(-ret)); 882 } 883 884 return !vfio_block_migration(vbasedev, err, errp); 885 } 886 887 if (!vbasedev->dirty_pages_supported) { 888 if (vbasedev->enable_migration == ON_OFF_AUTO_AUTO) { 889 error_setg(&err, 890 "%s: VFIO device doesn't support device dirty tracking", 891 vbasedev->name); 892 goto add_blocker; 893 } 894 895 warn_report("%s: VFIO device doesn't support device dirty tracking", 896 vbasedev->name); 897 } 898 899 ret = vfio_block_multiple_devices_migration(vbasedev, errp); 900 if (ret) { 901 goto out_deinit; 902 } 903 904 if (vfio_viommu_preset(vbasedev)) { 905 error_setg(&err, "%s: Migration is currently not supported " 906 "with vIOMMU enabled", vbasedev->name); 907 goto add_blocker; 908 } 909 910 trace_vfio_migration_realize(vbasedev->name); 911 return true; 912 913 add_blocker: 914 ret = vfio_block_migration(vbasedev, err, errp); 915 out_deinit: 916 if (ret) { 917 vfio_migration_deinit(vbasedev); 918 } 919 return !ret; 920 } 921 922 void vfio_migration_exit(VFIODevice *vbasedev) 923 { 924 if (vbasedev->migration) { 925 vfio_migration_deinit(vbasedev); 926 } 927 928 if (vbasedev->migration_blocker) { 929 migrate_del_blocker(vbasedev->migration_blocker); 930 error_free(vbasedev->migration_blocker); 931 vbasedev->migration_blocker = NULL; 932 } 933 } 934